Merge branch 'master' of https://wiccafe.de/kuro/bmc-tpl-code-all-around

test changes and added nightly build for gitea
Readme update
2026-10-28 23:04:53 +01:00 · 2026-10-28 23:04:50 +01:00 · 2026-10-28 21:12:22 +00:00 · 2026-10-28 21:10:39 +00:00 · 2026-10-28 22:04:56 +01:00 · 2026-10-28 00:14:29 +01:00
53 changed files with 21714 additions and 495 deletions
--- a/.gitea/workflows/nightly.yml
+++ b/.gitea/workflows/nightly.yml
@ -0,0 +1,46 @@
 name: Nightly Build
 on:
  schedule:
    # Läuft jeden Tag um 02:00 Uhr nachts
    - cron: '0 2 * * *'
  # Erlaubt es dir, den Build im Gitea-Webinterface auch manuell per Button zu starten
  workflow_dispatch:
 jobs:
  build-nightly:
    runs-on: ubuntu-latest # Pass das an das Label deines Gitea-Runners an
    steps:
      - name: Checkout Code
        uses: actions/checkout@v4
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '24' # Passend zu deiner package.json Umgebung
      - name: Install System Dependencies for Headless Tests
        run: |
          sudo apt-get update
          sudo apt-get install -y xvfb libx11-xcb1 libxcomposite1 libxcursor1 libxdamage1 libxi6 libxtst6 libnss3 libcups2 libxss1 libxrandr2 libasound2 libatk1.0-0 libatk-bridge2.0-0 libgtk-3-0
      - name: Install NPM Packages
        run: npm ci
      - name: Inject Nightly Version
        run: |
          NIGHTLY_DATE=$(date +%Y%m%d)
          sed -i "s/\"version\": \"\(.*\)\"/\"version\": \"\1-nightly-$NIGHTLY_DATE\"/" package.json
          echo "Building Nightly Version for $NIGHTLY_DATE..."
      - name: Package & Test (with xvfb)
        # xvfb-run fängt die GUI-Aufrufe der VS Code Test-Engine ab
        run: xvfb-run -a npm run package
      - name: Upload VSIX Artifact
        uses: actions/upload-artifact@v4
        with:
          name: bmc-tpl-code-all-around-nightly
          path: '*.vsix'
          retention-days: 14
--- a/.gitignore
+++ b/.gitignore
@ -3,3 +3,8 @@ dist
 node_modules
 .vscode-test/
 *.vsix
 src/*.js*
 src/test/*.js*
 out/*
 out/*/*
 out/*/*/*
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,9 +0,0 @@
 # Change Log
 All notable changes to the "bmc-tpl-code-all-around" extension will be documented in this file.
 Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how to structure this file.
 ## [Unreleased]
 - Initial release
--- a/LICENSE.md
+++ b/LICENSE.md
--- a/README.md
+++ b/README.md
@ -1,71 +1,199 @@
-# bmc-tpl-code-all-around README
+English Description first - after that comes the German Version.
 This is the README for your extension "bmc-tpl-code-all-around". After writing up a brief description, we recommend including the following sections.
 ## Features
 Describe specific features of your extension including screenshots of your extension in action. Image paths are relative to this README file.
 For example if there is an image subfolder under your extension project workspace:
 \!\[feature X\]\(images/feature-x.png\)
 > Tip: Many popular extensions utilize animations. This is an excellent way to show off your extension! We recommend short, focused animations that are easy to follow.
 ## Requirements
 If you have any requirements or dependencies, add a section describing those and how to install and configure them.
 ## Extension Settings
 Include if your extension adds any VS Code settings through the `contributes.configuration` extension point.
 For example:
 This extension contributes the following settings:
 * `myExtension.enable`: Enable/disable this extension.
 * `myExtension.thing`: Set to `blah` to do something.
 ## Known Issues
 Calling out known issues can help limit users opening duplicate issues against your extension.
 ## Release Notes
 Users appreciate release notes as you update your extension.
 ### 1.0.0
 Initial release of ...
 ### 1.0.1
 Fixed issue #.
 ### 1.1.0
 Added features X, Y, and Z.
 ---
-## Following extension guidelines
+# BMC TPL Code All-Around
-Ensure that you've read through the extensions guidelines and follow the best practices for creating your extension.
+**Linter, Auto-Formatter, IntelliSense, and Hover Documentation for the BMC TPL (Topology Pattern Language).**
-* [Extension Guidelines](https://code.visualstudio.com/api/references/extension-guidelines)
+This Visual Studio Code extension transforms your editor into a fully-fledged development environment for BMC Discovery TPL scripts. It saves you typing, formats code according to strict best practices, prevents syntax errors before deployment, and understands cross-project dependencies.
-## Working with Markdown
+---
-You can author your README using Visual Studio Code. Here are some useful editor keyboard shortcuts:
+## ✨ Features
-* Split the editor (`Cmd+\` on macOS or `Ctrl+\` on Windows and Linux).
+### 🤖 Intelligent Linter (Syntax Scanner)
-* Toggle preview (`Shift+Cmd+V` on macOS or `Shift+Ctrl+V` on Windows and Linux).
+The linter analyzes the code in real-time, remembers states across line breaks, and warns you about typical TPL errors:
-* Press `Ctrl+Space` (Windows, Linux, macOS) to see a list of Markdown snippets.
+* **Strict Hierarchy Checking:** Monitors the correct order of blocks within patterns and syncmappings (`metadata` -> `overview` -> `constants` -> `triggers` -> `mapping`/`removal` -> `body`).
 * **Smart Assignment Check:** Finds missing semicolons (but tolerates them in `enumeration` blocks or multi-line statements). Warns strictly with an error if `=` is used instead of `:=` for variable assignments (outside of legitimate `if`/`where` comparisons).
 * **Block & Bracket Tracking:** Detects unclosed blocks (like missing `end body;` or `end pattern;`) and finds unclosed parentheses `(` or brackets `[`.
 * **Mandatory Field Validation:** Checks if mandatory module-level metadata (`origin`, `author`, `products`, `publishers`, `tree_path`) are present based on your dynamic compliance settings, and if an initial `log.debug` statement exists in the `body`.
 * **Indentation Checking:** Instantly highlights messy indentation (any space count that is not a clean multiple of 4) with a warning, reminding you to use the Auto-Formatter.
 * **Unbreakable Lexer (New):** Built-in state-machine lexer correctly parses complex strings, triple-quotes (`"""`), and comments, ensuring accurate parameter counting and avoiding false-positive errors on complex TPL syntax.
 * **Version Checking:** Compares the TPL version declared in the module with the target version defined in your settings and warns about outdated scripts.
-## For more information
+### ⚙️ Configurable Plugin Settings & Compliance
 Personalize the plugin directly via the VS Code user interface (File > Preferences > Settings > Extensions > BMC TPL Settings):
 * **Metadata Compliance:** Define exact compliance rules for your workspace. Choose which metadata fields are mandatory and configure the `tree_path` strictly (e.g., minimum depth and forced static base nodes like `['MyCompany', 'IT']`).
 * **Default Metadata:** Store your own values for `Author`, `Publisher`, `Origin`, etc. These are automatically inserted when generating new modules.
 * **TPL Target Version:** Define the default TPL version (e.g., `23` for 1.23) you are developing for.
 * **Live Reload:** Changes to settings take effect immediately, no editor restart required.
-* [Visual Studio Code's Markdown Support](http://code.visualstudio.com/docs/languages/markdown)
+### 🎨 Auto-Formatter & Visual Alignment (`Shift + Alt + F`)
-* [Markdown Syntax Reference](https://help.github.com/articles/markdown-basics/)
+No more broken indentations! The formatter gets your code in top shape:
 * **VS Code Standard:** Strictly enforces 4 spaces per indentation level.
 * **Dynamic Block Indentation:** Automatically detects starting and ending blocks (`if`, `for`, `pattern`, `table`, etc.) and adjusts the indentation level.
 * **Bracket Memory (Visual Alignment):** The ultimate discipline! The formatter remembers the exact column position of opened arrays `[` or function calls `(` and flawlessly aligns all subsequent lines to this bracket.
 * **Uncompromising Cleanup (New):** Automatically strips all non-standard indentation (like 2, 3, or 6 spaces) and replaces it with exact, mathematically calculated 4-space blocks.
-**Enjoy!**
+### 💡 IntelliSense & Autocomplete (Cross-File)
 Saves an extreme amount of coding time through massive context awareness:
 * **"Go to Definition" (New):** Instantly navigate your codebase! `Ctrl+Click` (or `F12`) on any function call to jump directly to its declaration. Searches locally first and falls back to the RAM-based workspace index for cross-file jumps.
 * **Dynamic Taxonomy Support (New):** Full autocomplete support for dynamic BMC scopes. Typing `model.` suggests generic `<NodeKind>` constructors, while `model.rel.` offers dynamic `<Relationship>` constructors with ready-to-use snippets.
 * **Full BMC Standard Library:** Seamless integration of all built-in functions (e.g., `discovery`, `number`, `text`, `model`). Supports parameter overloads (e.g., `number.toText` optionally with or without a base) via Tab navigation.
 * **Workspace Scanning:** If you import a module (e.g., `from company.helpers import my_helper`), the plugin scans your entire project in the background. If you type `my_helper.`, it automatically suggests all available `define` methods.
 * **Case-Insensitive Resolution (New):** All method lookups (both Core and TKU) are completely case-insensitive, meaning `rdbms_functions.xyz` works just as flawlessly as `RDBMS_Functions.Xyz`.
 * **Local Namespaces:** Detects `definitions` blocks in the same file and suggests their methods.
 * **Variable Tracking:** Learns all variables you have defined with `:=` and suggests them to you later.
 ### 🔍 Hover Documentation (Tooltips)
 When you hover over a method name, a pattern, or a table:
 * **Official BMC Docs:** Full integration of the original, multi-line BMC documentation for all built-in functions loaded dynamically (no browser needed anymore!).
 * **DocString Extraction:** Reads custom multi-line comments (`"""` or `'''`) placed under `define` or `pattern` declarations and renders them as clean Markdown tooltips (even cross-project!).
 ### ⚡ Quick Fixes (Code Actions / Lightbulb)
 Offers immediate repair options with a single click:
 * **"Insert missing module metadata":** Instantly generates missing mandatory fields in the module metadata block based on your workspace compliance settings.
 * **"Insert log statement":** Adds the missing `log.debug("Start pattern...");` right at the beginning of the `body` block.
 * **"Tabs to Spaces":** Instantly replaces all illegal tabs (`\t`) in a line with 4 correct spaces each.
 ---
 ## 🚀 Snippets (Code Templates)
 Just type the keyword and press `Enter` to generate complete, perfectly indented blocks:
 | Keyword | Description |
 | :--- | :--- |
 | `tpl_skeleton` | **God-Snippet**: Generates a completely fresh TPL module. Automatically uses your configured compliance rules, settings, and dynamic tree paths. |
 | `metadata` | **Context-Aware**: Knows where your cursor is. Generates a full module block at the top, or a compact pattern block inside a pattern. |
 | `pattern` / `syncmapping` | Builds an empty pattern/syncmapping block including DocString and end-tag. |
 | `define` | Generates a method definition (`define name(params) ... end define;`). |
 | `overview`, `body`... | Builds the respective block and places the cursor right in the middle. |
 | `table` | Creates a table including the `default -> "unknown";` fallback. |
 | `if`, `elif`, `else` | Builds conditional statements incl. `then` and `end if;`, placing the cursor neatly at the condition. |
 | `for`, `while` | Builds standard loops incl. `do` and end-tag, letting you iterate directly. |
 ---
 ## 🛠️ Installation & Usage
 1. Activate the plugin. (Download the latest from the releases and simply drag the `.vsix` file into the Visual Studio Code add-ons).
 2. Open a TPL file in your project and let the analysis run.
 3. The linter starts automatically with every keystroke.
 4. **Formatting:** Right-click -> *Format Document* (or `Shift + Alt + F`).
 5. **Autocomplete:** Triggers automatically while typing, especially after a dot (`.`) during module calls.
 6. **Navigation:** Press `Ctrl` + Click (or `F12`) to jump to function definitions.
 7. **Quick Fixes:** Click the yellow/red lightbulb at the beginning of the line or press `Ctrl + .` (Windows/Linux) / `Cmd + .` (Mac).
 ---
 ## 📜 License
 This project is licensed under the **MIT License**.
 Copyright (c) 2026 Thomas Wehnert
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED.
 ---
 ---
 # BMC TPL Code All-Around
 **Linter, Auto-Formatter, IntelliSense und Hover-Dokumentationen für die BMC TPL (Template Language).**
 Diese Visual Studio Code Erweiterung verwandelt deinen Editor in eine vollwertige Entwicklungsumgebung für BMC Discovery TPL-Skripte. Sie nimmt dir Tipparbeit ab, formatiert Code nach strengen Best Practices, verhindert Syntax-Fehler noch vor dem Deployment und versteht projektübergreifende Abhängigkeiten.
 ---
 ## ✨ Features
 ### 🤖 Intelligenter Linter (Syntax-Scanner)
 Der Linter analysiert den Code in Echtzeit, merkt sich Zustände über Zeilenumbrüche hinweg und warnt vor typischen TPL-Fehlern:
 * **Strikte Hierarchie-Prüfung:** Überwacht die korrekte Reihenfolge der Blöcke innerhalb von Patterns und Syncmappings (`metadata` -> `overview` -> `constants` -> `triggers` -> `mapping`/`removal` -> `body`).
 * **Smarter Zuweisungs-Check:** Findet fehlende Semikolons (toleriert sie aber in `enumeration`-Blöcken oder bei umgebrochenen Code-Zeilen). Warnt streng mit einem Fehler, wenn `=` anstelle von `:=` für Variablenzuweisungen genutzt wird (außerhalb von legitimen `if`/`where` Vergleichen).
 * **Block- & Klammer-Tracking:** Erkennt nicht geschlossene Blöcke (wie fehlende `end body;` oder `end pattern;`) und findet ungeschlossene runde `(` oder eckige `[` Klammern.
 * **Pflichtfeld-Validierung:** Prüft basierend auf deinen dynamischen Compliance-Settings, ob auf Modul-Ebene zwingend benötigte Metadaten (`origin`, `author`, `tree_path` etc.) vorhanden sind und ob im `body` ein initiales `log.debug` Statement steht.
 * **Einrückungs-Prüfung:** Ein Check im Hintergrund markiert unsaubere Einrückungen (alles, was kein sauberes Vielfaches von 4 Leerzeichen ist) sofort mit einer Warnung, um an den Auto-Formatter zu erinnern.
 * **Unzerstörbarer Lexer (Neu):** Ein eingebauter State-Machine-Lexer verarbeitet komplexe Strings, Triple-Quotes (`"""`) und Kommentare fehlerfrei. Dadurch zählt der Linter Parameter immer korrekt und wirft keine falschen Fehler bei komplexer TPL-Syntax.
 * **Versions-Prüfung:** Gleicht die im Modul deklarierte TPL-Version mit der in deinen Settings definierten Version ab und warnt vor veralteten Skripten.
 ### ⚙️ Konfigurierbare Plugin-Einstellungen & Compliance
 Personalisiere das Plugin direkt über die VS Code Benutzeroberfläche (File > Preferences > Settings > Extensions > BMC TPL Einstellungen):
 * **Metadaten-Compliance:** Definiere exakte Regeln für deinen Workspace. Wähle, welche Felder Pflicht sind und konfiguriere den `tree_path` strikt (z.B. Mindest-Ebenen und feste Basis-Nodes wie `['MeineFirma', 'IT']`).
 * **Standard Metadaten:** Hinterlege deine eigenen Werte für `Author`, `Publisher`, `Origin` etc. Diese werden beim Generieren neuer Module automatisch eingesetzt.
 * **TPL Zielversion:** Definiere die TPL-Version (z.B. `23` für 1.23), für die du standardmäßig entwickelst.
 * **Live-Reload:** Änderungen an den Einstellungen greifen sofort, ganz ohne Neustart des Editors.
 ### 🎨 Auto-Formatter & Visual Alignment (`Shift + Alt + F`)
 Schluss mit kaputten Einrückungen! Der Formatter bringt deinen Code in Bestform:
 * **VS Code Standard:** Erzwingt strikt 4 Leerzeichen pro Einrückungs-Ebene.
 * **Dynamische Block-Einrückung:** Erkennt automatisch startende und endende Blöcke (`if`, `for`, `pattern`, `table` etc.) und passt die Einrückungsebene an.
 * **Klammer-Gedächtnis (Visual Alignment):** Die Königsdisziplin! Der Formatter merkt sich die spaltengenaue Position von geöffneten Arrays `[` oder Funktionsaufrufen `(` und richtet alle Folgezeilen makellos an dieser Klammer aus.
 * **Kompromisslose Bereinigung (Neu):** Unsaubere Einrückungen (z.B. 2, 3 oder 6 Leerzeichen) werden restlos rasiert und durch exakt berechnete 4-Space-Blöcke ersetzt.
 ### 💡 IntelliSense & Autovervollständigung (Cross-File)
 Spart extrem viel Zeit beim Coden durch massives Kontext-Wissen:
 * **"Go to Definition" (Neu):** Navigiere sofort durch deine Codebase! `Strg+Klick` (oder `F12`) auf einen Funktionsaufruf springt direkt zur Deklaration. Sucht erst lokal und weicht für dateiübergreifende Aufrufe blitzschnell auf den RAM-Index aus.
 * **Dynamische Taxonomie (Neu):** Voller Support für dynamische BMC-Scopes. Das Tippen von `model.` schlägt einen generischen `<NodeKind>`-Konstruktor vor, während `model.rel.` dynamische `<Relationship>`-Konstruktoren mit fertigen Snippets anbietet.
 * **Volle BMC Standard-Bibliothek:** Nahtlose Integration aller Built-In Funktionen (z.B. `discovery`, `number`, `text`, `model`). Unterstützt Parameter-Überladungen (z.B. `number.toText` wahlweise mit oder ohne Basis) per Tab-Navigation.
 * **Workspace-Scanning:** Importierst du ein Modul (z.B. `from company.helpers import my_helper`), durchsucht das Plugin im Hintergrund dein gesamtes Projekt. Tippst du `my_helper.`, werden dir automatisch alle verfügbaren `define`-Methoden vorgeschlagen.
 * **Case-Insensitive Auswertung (Neu):** Alle Methoden (Core und TKU) werden nun komplett groß-/kleinschreibungsunabhängig aufgelöst (`rdbms_functions.xyz` funktioniert genauso tadellos wie `RDBMS_Functions.Xyz`).
 * **Lokale Namespaces:** Erkennt `definitions`-Blöcke in der gleichen Datei und schlägt deren Methoden vor.
 * **Variablen-Tracking:** Lernt alle Variablen, die du mit `:=` definiert hast, und schlägt sie dir später vor.
 ### 🔍 Hover-Dokumentation (Tooltips)
 Wenn du mit der Maus über einem Methodennamen, einem Pattern oder einer Tabelle stehen bleibst:
 * **Offizielle BMC Doku:** Volle Integration der originalen, mehrzeiligen BMC Dokumentationen für alle eingebauten Funktionen (kein Browser mehr nötig!).
 * **DocString Extraction:** Liest eigene Multi-Line-Kommentare (`"""` oder `'''`) aus, die unter `define` oder `pattern` Deklarationen stehen, und rendert sie als saubere Markdown-Tooltips (auch projektübergreifend!).
 ### ⚡ Quick Fixes (Code Actions / Glühbirne)
 Bietet sofortige Reparaturoptionen mit einem Klick:
 * **"Fehlende Modul-Metadaten einfügen":** Generiert sofort alle fehlenden Pflichtfelder im Modul-Metadata-Block, basierend auf deinen Compliance-Settings.
 * **"Log-Statement einfügen":** Baut das fehlende `log.debug("Start pattern...");` direkt am Anfang des `body`-Blocks ein.
 * **"Tabs zu Spaces":** Ersetzt sofort alle illegalen Tabs (`\t`) in einer Zeile durch jeweils 4 korrekte Leerzeichen.
 ---
 ## 🚀 Snippets (Code-Vorlagen)
 Einfach das Keyword tippen und `Enter` drücken, um komplette, perfekt eingerückte Blöcke zu generieren:
 | Keyword | Beschreibung |
 | :--- | :--- |
 | `tpl_skeleton` | **God-Snippet**: Generiert ein komplett frisches TPL Modul. Nutzt automatisch deine hinterlegten Settings, dynamischen Tree-Paths und Compliance-Regeln. |
 | `metadata` | **Kontext-sensitiv**: Weiß genau, wo dein Cursor steht. Generiert einen großen Modul-Block ganz oben oder einen kompakten Pattern-Block innerhalb eines Patterns. |
 | `pattern` / `syncmapping` | Baut einen leeren Pattern/Syncmapping-Block inklusive DocString und End-Tag. |
 | `define` | Generiert eine Methodendefinition (`define name(params) ... end define;`). |
 | `overview`, `body`... | Baut den jeweiligen Block auf und platziert den Cursor in der Mitte. |
 | `table` | Erstellt eine Tabelle inklusive des `default -> "unknown";` Fallbacks. |
 | `if`, `elif`, `else` | Baut bedingte Abfragen inkl. `then` und `end if;` und platziert den Cursor sauber bei der Bedingung. |
 | `for`, `while` | Baut Standard-Schleifen inkl. `do` und End-Tag und lässt dich direkt iterieren. |
 ---
 ## 🛠️ Installation & Nutzung
 1. Das Plugin aktivieren. (Von den Releases das neueste herunterladen und einfach die `.vsix` Datei in die Add-ons von Visual Studio Code ziehen).
 2. In einem Projekt mit TPL Dateien eine davon öffnen und die Analyse durchlaufen lassen.
 3. Der Linter startet automatisch bei jedem Tastendruck.
 4. **Formatieren:** Rechtsklick -> *Dokument formatieren* (oder `Shift + Alt + F`).
 5. **Autovervollständigung:** Triggert automatisch beim Tippen, speziell nach einem Punkt (`.`) bei Modul-Aufrufen.
 6. **Navigieren:** Mit `Strg` + Klick (oder `F12`) direkt zu Funktionsdefinitionen springen.
 7. **Quick Fixes:** Auf die gelbe/rote Glühbirne am Zeilenanfang klicken oder `Ctrl + .` (Windows/Linux) / `Cmd + .` (Mac) drücken.
 ---
 ## 📜 Lizenz
 Dieses Projekt ist unter der **MIT License** lizenziert.
 Copyright (c) 2026 Thomas Wehnert
 Jedem, der eine Kopie dieser Software erhält, wird hiermit kostenlos die Erlaubnis erteilt, ohne Einschränkung mit der Software zu handeln, einschließlich und ohne Einschränkung der Rechte zur Nutzung, zum Kopieren, Ändern, Zusammenführen, Veröffentlichen, Verteilen, Unterlizenzieren und/oder Verkaufen von Kopien der Software, sofern der obige Urheberrechtshinweis und dieser Genehmigungshinweis in allen Kopien oder wesentlichen Teilen der Software enthalten sind. Die Software wird "ohne Mängelgewähr" (as is) zur Verfügung gestellt.
 ```eof
--- a/build_release.sh
+++ b/build_release.sh
@ -0,0 +1 @@
 vsce package
--- a/icon.png
+++ b/icon.png
--- a/linter_fixes.sh
+++ b/linter_fixes.sh
@ -0,0 +1 @@
 npm run lint -- --fix
--- a/package.json
+++ b/package.json
@ -1,21 +1,129 @@
 {
  "name": "bmc-tpl-code-all-around",
  "displayName": "BMC TPL Code All around",
-  "description": "Code linter, tracker and all around tool for coding in BMC Helix TPL",
+  "description": "Linter, Auto-Formatter, IntelliSense und Hover-Dokumentationen für die BMC TPL (Template Language). Verwandelt VS Code in eine vollwertige IDE.",
  "version": "0.0.1",
  "publisher": "kuro",
  "author": "Thomas Wehnert",
  "license": "MIT",
  "icon": "icon.png",
  "engines": {
    "vscode": "^1.140.0"
  },
  "repository": {
    "type": "git",
    "url": "https://wiccafe.de/kuro/bmc-tpl-code-all-around.git"
  },
  "categories": [
-    "Other"
+    "Linters",
    "Formatters",
    "Programming Languages",
    "Snippets"
  ],
-  "activationEvents": [],
+  "keywords": [
    "bmc",
    "discovery",
    "tpl",
    "linter",
    "formatter",
    "intellisense",
    "autocomplete"
  ],
  "activationEvents": [
     "onLanguage:tpl"
   ],
  "main": "./dist/extension.js",
  "contributes": {
-    "commands": [
+    "configuration": {
      "title": "BMC TPL Settings",
      "properties": {
        "tpl.metadata.author": {
          "type": "string",
          "default": "Autor",
          "description": "Standard-Author for new generated TPL-Modules."
        },
        "tpl.metadata.origin": {
          "type": "string",
          "default": "Custom",
          "description": "Standard-Origin for new generated TPL-Modules."
        },
        "tpl.metadata.publisher": {
          "type": "string",
          "default": "IT-Operations",
          "description": "Standard-Publisher for new generated TPL-Modules."
        },
        "tpl.metadata.treePathBase": {
          "type": "string",
          "default": "Company",
          "description": "First Part (Basis) of the tree_paths in the Metadata."
        },
        "tpl.metadata.require.origin": {
          "type": "boolean",
          "default": true,
          "description": "Marks 'origin' as Required on module level."
        },
        "tpl.metadata.require.author": {
          "type": "boolean",
          "default": true,
          "description": "Marks 'author' as Required on module level."
        },
        "tpl.metadata.require.products": {
          "type": "boolean",
          "default": true,
          "description": "Marks 'products' aas Required on module level."
        },
        "tpl.metadata.require.publishers": {
          "type": "boolean",
          "default": true,
          "description": "Marks 'publishers' as Required on module level."
        },
        "tpl.metadata.require.treePath": {
          "type": "boolean",
          "default": true,
          "description": "Marks 'tree_path' as Required on module level."
        },
        "tpl.metadata.treePath.minLevels": {
          "type": "number",
          "default": 3,
          "description": "How many levels should the tree_path in Metadata at least have? (e.g. 3 for 'Base', 'Category', 'Subcategory')."
        },
        "tpl.metadata.treePath.staticNodes": {
          "type": "array",
          "items": { "type": "string" },
          "default": [""],
          "description": "Fixed definitions for the tree_path left to right (e.g. ['Company', 'Software']). The rest of the levels are free to choose."
        },
        "tpl.version": {
          "type": "number",
          "default": 23,
          "description": "Current TPL-Subversion (e. g. 23 for TPL 1.23). Used to find old Modules and for auto generating the sceleton."
        },
        "tpl.rules.requireBodyLog": {
         "type": "boolean",
         "default": true,
         "description": "Require a log.debug statement at the start of a pattern's body phase."
        }
      },
      "commands": [
      {
-        "command": "bmc-tpl-code-all-around.helloWorld",
+        "command": "tpl.scanWorkspace",
-        "title": "Hello World"
+        "title": "TPL: Gesamten Workspace prüfen"
      }
    ]
    },
    "languages": [
      {
        "id": "tpl",
        "aliases": ["TPL", "tpl"],
        "extensions": [".tpl"],
        "configuration": "./language-configuration.json"
      }
    ],
    "grammars": [
      {
        "language": "tpl",
        "scopeName": "source.tpl",
        "path": "./syntaxes/tpl.tmLanguage.json"
      }
    ]
  },
@ -25,13 +133,14 @@
    "watch": "npm-run-all -p watch:*",
    "watch:esbuild": "node esbuild.js --watch",
    "watch:tsc": "tsc --noEmit --watch --project tsconfig.json",
-    "package": "npm run check-types && npm run lint && node esbuild.js --production",
+    "package": "npm run check-types && npm run lint && npm run test && node esbuild.js --production",
    "compile-tests": "tsc -p . --outDir out",
    "watch-tests": "tsc -p . -w --outDir out",
    "pretest": "npm run compile-tests && npm run compile && npm run lint",
    "check-types": "tsc --noEmit",
    "lint": "eslint src",
-    "test": "vscode-test"
+    "test": "vscode-test",
    "generate-builtins": "python scripts/generate_builtins.py ."
  },
  "devDependencies": {
    "@types/vscode": "^1.140.0",
@ -44,9 +153,5 @@
    "typescript": "^6.0.3",
    "@vscode/test-cli": "^0.0.15",
    "@vscode/test-electron": "^3.0.0"
  },
  "overrides": {
    "diff": "^8.0.4",
    "serialize-javascript": "^7.0.6"
  }
 }
--- a/src/TplCodeActionProvider.ts
+++ b/src/TplCodeActionProvider.ts
@ -1,61 +0,0 @@
 import * as vscode from 'vscode';
 export class TplCodeActionProvider implements vscode.CodeActionProvider {
    provideCodeActions(document: vscode.TextDocument, range: vscode.Range | vscode.Selection, context: vscode.CodeActionContext, token: vscode.CancellationToken): vscode.ProviderResult<(vscode.CodeAction | vscode.Command)[]> {
        const actions: vscode.CodeAction[] = [];
        for (const diagnostic of context.diagnostics) {
            // Fix für fehlende Metadaten
            if (diagnostic.code === 'missing_metadata') {
                const fix = new vscode.CodeAction('Fehlende Metadaten einfügen', vscode.CodeActionKind.QuickFix);
                fix.edit = new vscode.WorkspaceEdit();
                const missingParts = diagnostic.message.replace('Fehlende Pflicht-Metadaten: ', '').split(', ');
                let insertText = '';
                // Wir nutzen hier auch konsequent die 3 Spaces für den Insert!
                if (missingParts.includes('author')) { insertText += `   author := 'Dein Name';\n`; }
                if (missingParts.includes('publisher')) { insertText += `   publisher := 'Dein Unternehmen';\n`; }
                if (missingParts.includes('origin')) { insertText += `   origin := 'Custom';\n`; }
                if (missingParts.includes('tree_path')) { insertText += `   tree_path := 'Eigener Pfad', 'Kategorie', 'Pattern';\n`; }
                fix.edit.insert(document.uri, new vscode.Position(diagnostic.range.start.line + 1, 0), insertText);
                fix.diagnostics = [diagnostic];
                fix.isPreferred = true;
                actions.push(fix);
            }
            // Fix für fehlenden Pattern-Start-Log
            if (diagnostic.code === 'missing_log_start') {
                const fix = new vscode.CodeAction('Log-Statement am Body-Anfang einfügen', vscode.CodeActionKind.QuickFix);
                fix.edit = new vscode.WorkspaceEdit();
                const expectedLog = diagnostic.source as string;
                const insertText = `   ${expectedLog}\n`; // Auch hier 3 Spaces
                fix.edit.insert(document.uri, new vscode.Position(diagnostic.range.start.line, 0), insertText);
                fix.diagnostics = [diagnostic];
                fix.isPreferred = true;
                actions.push(fix);
            }
            // Fix für Tabs (Ersetzen durch 3 Spaces)
            if (diagnostic.code === 'invalid_tab') {
                const fix = new vscode.CodeAction('Tabs in dieser Zeile durch 3 Spaces ersetzen', vscode.CodeActionKind.QuickFix);
                fix.edit = new vscode.WorkspaceEdit();
                const line = document.lineAt(diagnostic.range.start.line);
                const fixedText = line.text.replace(/\t/g, '   ');
                fix.edit.replace(document.uri, line.range, fixedText);
                fix.diagnostics = [diagnostic];
                fix.isPreferred = true;
                actions.push(fix);
            }
        }
        return actions;
    }
 }
--- a/src/TplDocumentFormatter.ts
+++ b/src/TplDocumentFormatter.ts
@ -1,40 +0,0 @@
 import * as vscode from 'vscode';
 export class TplDocumentFormatter implements vscode.DocumentFormattingEditProvider {
    provideDocumentFormattingEdits(document: vscode.TextDocument, options: vscode.FormattingOptions, token: vscode.CancellationToken): vscode.ProviderResult<vscode.TextEdit[]> {
        const edits: vscode.TextEdit[] = [];
        const lines = document.getText().split('\n');
        let indentLevel = 0;
        // Zwingt den Formatter strikt zu 3 Spaces (ignoriert VS Code Settings)
        const indentString = '   ';
        for (let i = 0; i < lines.length; i++) {
            let line = lines[i].trim();
            if (line.length === 0) { continue; } 
            // 1. Wenn die Zeile einen Block schließt, VORHER die Einrückung verringern
            if (line.match(/^(end\s+(pattern|table|if|for|while)|else|elif)\b/)) {
                indentLevel = Math.max(0, indentLevel - 1);
            }
            // 2. Die Zeile neu aufbauen (korrekte Einrückung + getrimmter Text)
            const newLineText = indentString.repeat(indentLevel) + line;
            // 3. Nur wenn sich was geändert hat, ein Edit erzeugen
            if (lines[i] !== newLineText && lines[i] !== newLineText + '\r') {
                const range = new vscode.Range(i, 0, i, lines[i].length);
                edits.push(vscode.TextEdit.replace(range, newLineText));
            }
            // 4. Wenn die Zeile einen Block öffnet, NACHHER die Einrückung erhöhen
            if (line.match(/^(pattern|table|metadata|overview|constants|triggers|body|if|for|while|else|elif)\b/)) {
                if (!line.startsWith('end ')) {
                    indentLevel++;
                }
            }
        }
        return edits;
    }
 }
--- a/src/core/LinterContext.ts
+++ b/src/core/LinterContext.ts
@ -0,0 +1,55 @@
 import * as vscode from 'vscode';
 export enum PatternPhase { None = 0, Metadata = 1, Overview = 2, Constants = 3, Triggers = 4, Mapping = 5, Removal = 6, Body = 7 }
 export class LinterContext {
    public diagnostics: vscode.Diagnostic[] = [];
    public configuredTplVersion: number = 23;
    public tplVersion: number = 10;
    // Status-Tracking
    public hasModuleDef = false;
    public inBlock: 'none' | 'pattern' | 'table' | 'definitions' | 'enumeration' | 'configuration' = 'none';
    public currentPatternPhase: PatternPhase = PatternPhase.None;
    public inMultiLineComment = false;
    public inConditionBlock = false;
    // Multi-Line Import-Tracking
    public inImportBlock = false;
    public currentImportModule = "";
    // String-Tracking (Basis-Lexer)
    public inTripleDouble = false;
    public inTripleSingle = false;
    public stringNeedsSemicolon = false;
    public justOpenedString = false;
    public isClosingString = false;
    public isInternalStringLine = false;
    // Block- & Metadaten-Tracking
    public activePhaseName = "";
    public activePhaseLine = -1;
    public currentPatternName = "";
    public inModuleMetadata = false;
    public hasModuleMetadata = false;
    public moduleMetadataBlockLine = -1;
    public foundModuleMetadata = new Set<string>();
    // Klammer-Tracking
    public parenStack: number[] = [];
    public bracketStack: number[] = [];
    public openDefines: number[] = [];
    public openControlBlocks: { type: string, lineIdx: number }[] = [];
    public addDiag(lineIdx: number, start: number, end: number, msg: string, severity: vscode.DiagnosticSeverity): vscode.Diagnostic {
        const diag = new vscode.Diagnostic(new vscode.Range(lineIdx, start, lineIdx, end), msg, severity);
        this.diagnostics.push(diag);
        return diag; 
    }
    public resetLineStates() {
        this.isInternalStringLine = false;
        this.justOpenedString = false;
        this.isClosingString = false;
    }
 }
--- a/src/core/TplLinter.ts
+++ b/src/core/TplLinter.ts
@ -0,0 +1,88 @@
 import * as vscode from 'vscode';
 import { LinterContext } from './LinterContext';
 import { SyntaxRule } from './rules/SyntaxRule';
 import { BlockRule } from './rules/BlockRule';
 import { MetadataRule } from './rules/MetadataRule';
 import { IndentationRule } from './rules/IndentationRule'; 
 import { ParameterRule } from './rules/ParameterRule';
 export function validateTplDocument(document: vscode.TextDocument, collection: vscode.DiagnosticCollection) {
    if (document.languageId !== 'tpl') {return;}
    const text = document.getText();
    const lines = text.split('\n');
    const ctx = new LinterContext();
    const rules = [
        new IndentationRule(), 
        new SyntaxRule(),
        new MetadataRule(), 
        new BlockRule(),
        new ParameterRule()
    ];
    for (let i = 0; i < lines.length; i++) {
        const rawLine = lines[i];
        const line = rawLine.trim();
        ctx.resetLineStates();
        // NEU: TODO-Check hier im Linter, BEVOR Kommentare ignoriert werden!
        const todoMatch = rawLine.match(/\bTODO\b\s*:?\s*(.*)/i);
        if (todoMatch) {
            ctx.addDiag(i, todoMatch.index!, rawLine.length, `TODO: ${todoMatch[1].trim()}`, vscode.DiagnosticSeverity.Information);
        }
        trackStrings(rawLine, line, ctx);
        if (ctx.isInternalStringLine && (ctx.inTripleDouble || ctx.inTripleSingle)) { continue; }
        if (line.startsWith('//') || line.startsWith('/*')) { 
            if (line.startsWith('/*')) { ctx.inMultiLineComment = true; } 
            continue; 
        }
        if (ctx.inMultiLineComment) { 
            if (line.includes('*/')) { ctx.inMultiLineComment = false; } 
            continue; 
        }
        if (line.length === 0) { continue; }
        // Regeln anwenden
        for (const rule of rules) {
            rule.checkLine(line, rawLine, i, ctx, lines);
        }
    }
    // Sicherer Aufruf für alle Regeln
    for (const rule of rules) {
        if (rule.checkEnd) {
            rule.checkEnd(lines, ctx);
        }
    }
    collection.set(document.uri, ctx.diagnostics);
 }
 // Interne Hilfsfunktion für den Parser
 function trackStrings(rawLine: string, line: string, ctx: LinterContext) {
    const tripleDoubleCount = (rawLine.match(/"""/g) || []).length;
    const tripleSingleCount = (rawLine.match(/'''/g) || []).length;
    if (ctx.inTripleDouble) {
        ctx.isInternalStringLine = true;
        if (tripleDoubleCount % 2 !== 0) { ctx.inTripleDouble = false; ctx.isClosingString = true; }
    } else if (tripleDoubleCount % 2 !== 0) {
        ctx.inTripleDouble = true; ctx.justOpenedString = true;
    }
    if (ctx.inTripleSingle) {
        ctx.isInternalStringLine = true;
        if (tripleSingleCount % 2 !== 0) { ctx.inTripleSingle = false; ctx.isClosingString = true; }
    } else if (tripleSingleCount % 2 !== 0 && !ctx.justOpenedString) {
        ctx.inTripleSingle = true; ctx.justOpenedString = true;
    }
    if (ctx.justOpenedString) { 
        ctx.stringNeedsSemicolon = !line.startsWith('"""') && !line.startsWith("'''"); 
    }
 }
--- a/src/core/TplLookup.ts
+++ b/src/core/TplLookup.ts
@ -0,0 +1,41 @@
 import { tplBuiltIns } from '../data/TplBuiltIns';
 import { generatedTplBuiltIns } from '../data/GeneratedTplBuiltIns';
 export class TplLookup {
    // Holt eine spezifische Methode (Case-Insensitive)
    public static getBuiltInFunction(namespace: string, funcName: string): any | null {
        const nsLower = namespace.toLowerCase();
        const fnLower = funcName.toLowerCase();
        // 1. Suche in Core Built-Ins (discovery, model, etc.)
        const coreKey = Object.keys(tplBuiltIns).find(k => k.toLowerCase() === nsLower);
        if (coreKey) {
            const methods = (tplBuiltIns as any)[coreKey];
            const mKey = Object.keys(methods).find(k => k.toLowerCase() === fnLower);
            if (mKey) {return methods[mKey];}
        }
        // 2. Suche in Generierten TKU Built-Ins (rdbms_functions, etc.)
        const tkuKey = Object.keys(generatedTplBuiltIns).find(k => k.toLowerCase() === nsLower);
        if (tkuKey) {
            const methods = (generatedTplBuiltIns as any)[tkuKey];
            const mKey = Object.keys(methods).find(k => k.toLowerCase() === fnLower);
            if (mKey) {return methods[mKey];}
        }
        return null;
    }
    // Holt alle Methoden eines Moduls für die Autovervollständigung (Case-Insensitive)
    public static getAllMethodsForNamespace(namespace: string): Record<string, any> | null {
        const nsLower = namespace.toLowerCase();
        const coreKey = Object.keys(tplBuiltIns).find(k => k.toLowerCase() === nsLower);
        if (coreKey) {return (tplBuiltIns as any)[coreKey];}
        const tkuKey = Object.keys(generatedTplBuiltIns).find(k => k.toLowerCase() === nsLower);
        if (tkuKey) {return (generatedTplBuiltIns as any)[tkuKey];}
        return null;
    }
 }
--- a/src/core/WorkspaceIndex.ts
+++ b/src/core/WorkspaceIndex.ts
@ -0,0 +1,133 @@
 import * as vscode from 'vscode';
 export interface TplFunctionSignature {
    name: string;
    moduleName: string;
    params: string[];
    docString?: string;
    hasReturnValue?: boolean;
    lineIdx: number;       // NEU: Für 'Go to Definition'
    fsPath: string;        // NEU: Für 'Go to Definition'
 }
 export class WorkspaceIndex {
    private fileIndex = new Map<string, Map<string, TplFunctionSignature>>();
    private fileModules = new Map<string, string>();
    private moduleDefinitions = new Map<string, Set<string>>();
    public updateFile(uri: vscode.Uri, text: string) {
        if (!uri.fsPath.endsWith('.tpl')) {return;}
        const fsPath = uri.fsPath;
        const lines = text.split('\n');
        let currentModule = "";
        let currentDefBlock = "";
        const functions = new Map<string, TplFunctionSignature>();
        const defBlocks = new Set<string>();
        const modMatch = text.match(/tpl\s+1\.\d+\s+module\s+([a-zA-Z0-9_.]+)\s*;/);
        if (modMatch) {
            currentModule = modMatch[1];
        }
        this.fileModules.set(fsPath, currentModule);
        for (let i = 0; i < lines.length; i++) {
            const line = lines[i];
            const defBlockMatch = line.match(/^\s*definitions?\s+([a-zA-Z0-9_]+)/);
            if (defBlockMatch) { 
                currentDefBlock = defBlockMatch[1]; 
                defBlocks.add(currentDefBlock);
                continue; 
            }
            if (line.match(/^\s*end\s+definitions?/)) { 
                currentDefBlock = ""; 
                continue; 
            }
            const structMatch = line.match(/^\s*(?:pattern|syncmapping|table)\s+([a-zA-Z0-9_]+)/);
            if (structMatch) {
                defBlocks.add(structMatch[1]);
            }
            const defineMatch = line.match(/^\s*define\s+([a-zA-Z0-9_]+)\b(?:\s*\((.*?)\))?/);
            if (defineMatch) {
                const funcName = defineMatch[1];
                const paramString = defineMatch[2] || "";
                const fullName = currentDefBlock ? `${currentDefBlock}.${funcName}` : funcName;
                const params = paramString.split(',').map(p => p.trim()).filter(p => p.length > 0);
                let docString = undefined;
                const textAfterDefine = text.substring(text.indexOf(line) + line.length);
                const docMatch = textAfterDefine.match(/^\s*(?:"""|''')([\s\S]*?)(?:"""|''')/);
                if (docMatch) { docString = docMatch[1].trim(); }
                let hasReturnValue = false;
                for (let j = i + 1; j < lines.length; j++) {
                    if (lines[j].match(/^\s*end\s+define/)) {break;}
                    if (lines[j].match(/^\s*return\b/)) {
                        hasReturnValue = true;
                        break;
                    }
                }
                functions.set(fullName, {
                    name: fullName,
                    moduleName: currentModule,
                    params: params,
                    docString: docString,
                    hasReturnValue: hasReturnValue,
                    lineIdx: i,
                    fsPath: fsPath
                });
            }
        }
        this.fileIndex.set(fsPath, functions);
        if (currentModule) {
            this.moduleDefinitions.set(currentModule, defBlocks);
        }
    }
    public removeFile(uri: vscode.Uri) {
        const moduleName = this.fileModules.get(uri.fsPath);
        if (moduleName) {
            this.moduleDefinitions.delete(moduleName);
        }
        this.fileIndex.delete(uri.fsPath);
        this.fileModules.delete(uri.fsPath);
    }
    public getAllModules(): string[] {
        return Array.from(this.moduleDefinitions.keys());
    }
    public getDefinitionBlocksForModule(moduleName: string): string[] {
        const blocks = this.moduleDefinitions.get(moduleName);
        return blocks ? Array.from(blocks) : [];
    }
    public getFunctionsForModule(moduleName: string): TplFunctionSignature[] {
        const result: TplFunctionSignature[] = [];
        for (const [fsPath, map] of this.fileIndex.entries()) {
            if (this.fileModules.get(fsPath) === moduleName) {
                result.push(...map.values());
            }
        }
        return result;
    }
    public getFunctionSignatures(funcName: string): TplFunctionSignature[] {
        const result: TplFunctionSignature[] = [];
        for (const map of this.fileIndex.values()) {
            for (const sig of map.values()) {
                if (sig.name === funcName || sig.name.endsWith(`.${funcName}`)) {
                    result.push(sig);
                }
            }
        }
        return result;
    }
 }
 export const workspaceIndex = new WorkspaceIndex();
--- a/src/core/rules/BlockRule.ts
+++ b/src/core/rules/BlockRule.ts
@ -0,0 +1,169 @@
 import * as vscode from 'vscode';
 import { LinterRule } from './LinterRule';
 import { LinterContext, PatternPhase } from '../LinterContext';
 export class BlockRule implements LinterRule {
    public checkLine(line: string, rawLine: string, lineIdx: number, ctx: LinterContext, lines: string[]): void {
        if (!ctx.hasModuleDef) {
            if (line.startsWith('tpl ')) { ctx.hasModuleDef = true; } 
            else { ctx.addDiag(lineIdx, 0, rawLine.length, "Every file must start with 'tpl 1.x module <name>;'.", vscode.DiagnosticSeverity.Error); ctx.hasModuleDef = true; }
        }
        // If we are inside the metadata block, we ignore the rest. MetadataRule handles it!
        if (ctx.inModuleMetadata || (line.startsWith('metadata') && ctx.inBlock === 'none')) {
            return; 
        }
        if (line.match(/^(pattern|syncmapping|table|definitions?|enumeration|configuration)\b/)) {
            if (!ctx.hasModuleMetadata && ctx.inBlock === 'none') {
                ctx.addDiag(lineIdx, 0, line.length, "A 'metadata' block at the module level is mandatory before defining other blocks.", vscode.DiagnosticSeverity.Error);
            }
        }
        this.handleBlockOpenings(line, rawLine, lineIdx, ctx);
        this.handleControlBlocks(line, rawLine, lineIdx, ctx);
        if (ctx.inBlock === 'pattern') {
            this.checkPatternPhases(line, rawLine, lineIdx, ctx, lines);
        }
        this.checkEndBlocks(line, rawLine, lineIdx, ctx);
    }
    public checkEnd(lines: string[], ctx: LinterContext): void {
        for (const unclosedLine of ctx.openDefines) { 
            ctx.addDiag(unclosedLine, 0, lines[unclosedLine].length, "Block 'define' was not closed with 'end define;'!", vscode.DiagnosticSeverity.Error); 
        }
        for (const block of ctx.openControlBlocks) {
            ctx.addDiag(block.lineIdx, 0, lines[block.lineIdx].length, `Block '${block.type}' was not closed with 'end ${block.type};'!`, vscode.DiagnosticSeverity.Error);
        }
    }
    private handleControlBlocks(line: string, rawLine: string, lineIdx: number, ctx: LinterContext) {
        if (/^if\b/.test(line)) { ctx.openControlBlocks.push({ type: 'if', lineIdx }); }
        else if (/^for\b/.test(line)) { ctx.openControlBlocks.push({ type: 'for', lineIdx }); }
        else if (/^while\b/.test(line)) { ctx.openControlBlocks.push({ type: 'while', lineIdx }); }
        if (line.startsWith('end if')) { this.closeControlBlock('if', line, lineIdx, ctx); }
        else if (line.startsWith('end for')) { this.closeControlBlock('for', line, lineIdx, ctx); }
        else if (line.startsWith('end while')) { this.closeControlBlock('while', line, lineIdx, ctx); }
    }
    private closeControlBlock(expectedType: string, line: string, lineIdx: number, ctx: LinterContext) {
        if (ctx.openControlBlocks.length === 0) {
            ctx.addDiag(lineIdx, 0, line.length, `Found 'end ${expectedType}' without an open block.`, vscode.DiagnosticSeverity.Error);
            return;
        }
        const lastBlock = ctx.openControlBlocks.pop()!;
        if (lastBlock.type !== expectedType) {
            ctx.addDiag(lineIdx, 0, line.length, `Wrong end. Expected: 'end ${lastBlock.type};', found: 'end ${expectedType};'.`, vscode.DiagnosticSeverity.Error);
            ctx.openControlBlocks.push(lastBlock);
        }
    }
    private handleBlockOpenings(line: string, rawLine: string, lineIdx: number, ctx: LinterContext) {
        if (line.startsWith('definitions ') || line.startsWith('definition ')) {
            if (ctx.inBlock !== 'none') { ctx.addDiag(lineIdx, 0, line.length, "A 'definitions' block must be declared at the top level.", vscode.DiagnosticSeverity.Error); }
            ctx.inBlock = 'definitions'; 
        }
        else if (line.startsWith('define ')) { ctx.openDefines.push(lineIdx); }
        else if (line.startsWith('enumeration ')) {
            if (ctx.inBlock !== 'none') { ctx.addDiag(lineIdx, 0, line.length, "An 'enumeration' must be declared at the top level.", vscode.DiagnosticSeverity.Error); }
            ctx.inBlock = 'enumeration'; 
        }
        else if (line.startsWith('configuration ')) {
            if (ctx.inBlock !== 'none') { ctx.addDiag(lineIdx, 0, line.length, "A 'configuration' must be declared at the top level.", vscode.DiagnosticSeverity.Error); }
            ctx.inBlock = 'configuration'; 
        }
        else if (line.startsWith('pattern ') || line.startsWith('syncmapping ')) {
            if (ctx.inBlock !== 'none') { ctx.addDiag(lineIdx, 0, 7, "A pattern or syncmapping cannot be declared inside another block.", vscode.DiagnosticSeverity.Error); }
            ctx.inBlock = 'pattern';
            ctx.currentPatternPhase = PatternPhase.None;
            ctx.activePhaseName = "";
            ctx.activePhaseLine = -1;
            const nameMatch = line.match(/(pattern|syncmapping)\s+([a-zA-Z0-9_]+)\s+\d+\.\d+/);
            if (nameMatch) { ctx.currentPatternName = nameMatch[2]; } 
            else { ctx.addDiag(lineIdx, 0, rawLine.length, "Invalid pattern declaration. Expected: 'pattern <Name> <Version>'", vscode.DiagnosticSeverity.Error); }
        }
        else if (line.startsWith('table ')) {
            if (ctx.inBlock !== 'none') { ctx.addDiag(lineIdx, 0, 5, "A table cannot be declared inside another block.", vscode.DiagnosticSeverity.Error); }
            ctx.inBlock = 'table';
        }
    }
    private checkPatternPhases(line: string, rawLine: string, lineIdx: number, ctx: LinterContext, lines: string[]) {
        const checkPhase = (phaseName: string, phaseEnum: PatternPhase) => {
            if (line.startsWith(phaseName)) {
                if (ctx.activePhaseName !== "") { ctx.addDiag(ctx.activePhaseLine, 0, ctx.activePhaseName.length, `Block '${ctx.activePhaseName}' was not closed with 'end ${ctx.activePhaseName};'.`, vscode.DiagnosticSeverity.Error); }
                if (ctx.currentPatternPhase >= phaseEnum) { ctx.addDiag(lineIdx, 0, phaseName.length, `Block '${phaseName}' is not allowed here.`, vscode.DiagnosticSeverity.Error); }
                ctx.currentPatternPhase = phaseEnum;
                ctx.activePhaseName = phaseName;
                ctx.activePhaseLine = lineIdx;
            }
        };
        checkPhase('metadata', PatternPhase.Metadata);
        checkPhase('overview', PatternPhase.Overview);
        checkPhase('constants', PatternPhase.Constants);
        checkPhase('triggers', PatternPhase.Triggers);
        checkPhase('mapping', PatternPhase.Mapping);
        checkPhase('removal', PatternPhase.Removal);
        if (line.startsWith('body')) {
            if (ctx.activePhaseName !== "") { ctx.addDiag(ctx.activePhaseLine, 0, ctx.activePhaseName.length, `Block '${ctx.activePhaseName}' was not closed with 'end ${ctx.activePhaseName};'.`, vscode.DiagnosticSeverity.Error); }
            ctx.activePhaseName = "body";
            ctx.activePhaseLine = lineIdx;
            const config = vscode.workspace.getConfiguration('tpl');
            const requireLog = config.get<boolean>('rules.requireBodyLog', true);
            if (requireLog) {
                let foundLog = false;
                for (let j = lineIdx + 1; j < lines.length; j++) {
                    const aheadLine = lines[j].trim();
                    if (aheadLine.startsWith('end pattern') || aheadLine.startsWith('end syncmapping')) { break; }
                    if (aheadLine.includes('log.debug') && aheadLine.includes(ctx.currentPatternName)) { foundLog = true; break; }
                }
                if (!foundLog) {
                    const expectedLog = `log.debug("Start pattern ${ctx.currentPatternName}");`;
                    const diag = ctx.addDiag(lineIdx, 0, rawLine.length, `Missing log statement with pattern name in body. E.g.: ${expectedLog}`, vscode.DiagnosticSeverity.Error);
                    diag.code = 'missing_log_start'; 
                    diag.source = expectedLog;       
                }
            }
        }
        const closers = ['end metadata', 'end overview', 'end constants', 'end triggers', 'end mapping', 'end removal', 'end body'];
        for (const closer of closers) {
            if (line.startsWith(closer)) {
                const phase = closer.replace('end ', '').replace(';', '').trim();
                if (ctx.activePhaseName !== phase) { ctx.addDiag(lineIdx, 0, line.length, `Unexpected '${closer}'. Expected 'end ${ctx.activePhaseName};'.`, vscode.DiagnosticSeverity.Error); } 
                else { ctx.activePhaseName = ""; }
            }
        }
    }
    private checkEndBlocks(line: string, rawLine: string, lineIdx: number, ctx: LinterContext) {
        if (line.startsWith('end pattern') || line.startsWith('end syncmapping')) {
            if (ctx.activePhaseName !== "") { ctx.addDiag(ctx.activePhaseLine, 0, ctx.activePhaseName.length, `Block '${ctx.activePhaseName}' was not closed with 'end ${ctx.activePhaseName};'.`, vscode.DiagnosticSeverity.Error); }
            if (ctx.inBlock !== 'pattern') { ctx.addDiag(lineIdx, 0, 11, "Found 'end pattern' without an open pattern block.", vscode.DiagnosticSeverity.Error); }
            ctx.inBlock = 'none';
        }
        else if (line.startsWith('end table') || line.startsWith('end enumeration') || line.startsWith('end configuration')) {
            ctx.inBlock = 'none';
        }
        else if (line.startsWith('end definitions') || line.startsWith('end definition')) {
            if (ctx.inBlock !== 'definitions') { ctx.addDiag(lineIdx, 0, line.length, "Found 'end definitions' without an open definitions block.", vscode.DiagnosticSeverity.Error); }
            ctx.inBlock = 'none';
        }
        else if (line.startsWith('end define')) {
            if (ctx.openDefines.length > 0) { ctx.openDefines.pop(); }
            else { ctx.addDiag(lineIdx, 0, line.length, "Found 'end define' without an open 'define'.", vscode.DiagnosticSeverity.Error); }
        }
    }
 }
--- a/src/core/rules/IndentationRule.ts
+++ b/src/core/rules/IndentationRule.ts
@ -0,0 +1,34 @@
 import * as vscode from 'vscode';
 import { LinterRule } from './LinterRule';
 import { LinterContext } from '../LinterContext';
 export class IndentationRule implements LinterRule {
    public checkLine(line: string, rawLine: string, lineIdx: number, ctx: LinterContext, lines: string[]): void {
        if (rawLine.trim().length === 0) {return;}
        if (rawLine.includes('\t')) {return;}
        // Sobald wir in Klammern oder einem Multi-Line Import sind (Visual Alignment),
        // greift die 4-Leerzeichen-Regel nicht!
        if (ctx.parenStack.length > 0 || ctx.bracketStack.length > 0 || ctx.inImportBlock) {
            return;
        }
        const leadingSpacesMatch = rawLine.match(/^ +/);
        const spaceCount = leadingSpacesMatch ? leadingSpacesMatch[0].length : 0;
        if (spaceCount > 0 && spaceCount % 4 !== 0) {
            ctx.addDiag(
                lineIdx, 
                0, 
                spaceCount,
                `Invalid indentation (${spaceCount} spaces). Please use a multiple of 4. (Tip: Shift+Alt+F to auto-format)`, 
                vscode.DiagnosticSeverity.Warning
            );
        }
    }
    public checkEnd(lines: string[], ctx: LinterContext): void {
        // empty
    }
 }
--- a/src/core/rules/LinterRule.ts
+++ b/src/core/rules/LinterRule.ts
@ -0,0 +1,6 @@
 import { LinterContext } from '../LinterContext';
 export interface LinterRule {
    checkLine(line: string, rawLine: string, lineIdx: number, ctx: LinterContext, lines: string[]): void;
    checkEnd?(lines: string[], ctx: LinterContext): void;
 }
--- a/src/core/rules/MetadataRule.ts
+++ b/src/core/rules/MetadataRule.ts
@ -0,0 +1,76 @@
 import * as vscode from 'vscode';
 import { LinterRule } from './LinterRule';
 import { LinterContext } from '../LinterContext';
 export class MetadataRule implements LinterRule {
    public checkLine(line: string, rawLine: string, lineIdx: number, ctx: LinterContext, lines: string[]): void {
        if (line.startsWith('metadata') && ctx.inBlock === 'none') {
            ctx.inModuleMetadata = true;
            ctx.hasModuleMetadata = true;
            ctx.moduleMetadataBlockLine = lineIdx;
            ctx.foundModuleMetadata.clear();
            return;
        }
        if (ctx.inModuleMetadata) {
            const config = vscode.workspace.getConfiguration('tpl');
            if (line.match(/^origin\b/)) {ctx.foundModuleMetadata.add('origin');}
            if (line.match(/^author\b/)) {ctx.foundModuleMetadata.add('author');}
            if (line.match(/^products\b/)) {ctx.foundModuleMetadata.add('products');}
            if (line.match(/^publishers\b/)) {ctx.foundModuleMetadata.add('publishers');}
            if (line.match(/^tree_path\b/)) {
                ctx.foundModuleMetadata.add('tree_path');
                if (config.get<boolean>('metadata.require.treePath', true)) {
                    this.checkTreePath(line, rawLine, lineIdx, ctx, config);
                }
            }
            if (line.startsWith('end metadata')) {
                ctx.inModuleMetadata = false;
                this.checkRequiredFields(ctx, config);
            }
        }
    }
    private checkTreePath(line: string, rawLine: string, lineIdx: number, ctx: LinterContext, config: vscode.WorkspaceConfiguration) {
        const minLevels = config.get<number>('metadata.treePath.minLevels', 3);
        const staticNodes = config.get<string[]>('metadata.treePath.staticNodes', ['Grafing']); // Fallback
        const match = line.match(/tree_path\s*:=\s*(.*);/);
        if (match) {
            const paths = match[1].split(',').map(s => s.trim().replace(/^['"]|['"]$/g, ''));
            if (paths.length < minLevels) {
                ctx.addDiag(lineIdx, 0, rawLine.length, `The tree_path must contain at least ${minLevels} levels.`, vscode.DiagnosticSeverity.Error);
            }
            for (let i = 0; i < staticNodes.length; i++) {
                if (paths[i] !== staticNodes[i]) {
                    ctx.addDiag(lineIdx, 0, rawLine.length, `Tree path level ${i + 1} must strictly be '${staticNodes[i]}'.`, vscode.DiagnosticSeverity.Error);
                }
            }
        }
    }
    private checkRequiredFields(ctx: LinterContext, config: vscode.WorkspaceConfiguration) {
        const requiredFields: string[] = [];
        if (config.get<boolean>('metadata.require.origin', true)) {requiredFields.push('origin');}
        if (config.get<boolean>('metadata.require.author', true)) {requiredFields.push('author');}
        if (config.get<boolean>('metadata.require.products', true)) {requiredFields.push('products');}
        if (config.get<boolean>('metadata.require.publishers', true)) {requiredFields.push('publishers');}
        if (config.get<boolean>('metadata.require.treePath', true)) {requiredFields.push('tree_path');}
        const missing = requiredFields.filter(f => !ctx.foundModuleMetadata.has(f));
        if (missing.length > 0 && ctx.moduleMetadataBlockLine !== -1) {
            const diag = ctx.addDiag(ctx.moduleMetadataBlockLine, 0, 8, `Missing mandatory module metadata fields: ${missing.join(', ')}`, vscode.DiagnosticSeverity.Error);
            diag.code = 'missing_module_metadata'; 
        }
    }
    public checkEnd(lines: string[], ctx: LinterContext): void {
        // empty
    }
 }
--- a/src/core/rules/ParameterRule.ts
+++ b/src/core/rules/ParameterRule.ts
@ -0,0 +1,157 @@
 import * as vscode from 'vscode';
 import { LinterRule } from './LinterRule';
 import { LinterContext } from '../LinterContext';
 import { workspaceIndex, TplFunctionSignature } from '../WorkspaceIndex';
 import { TplLookup } from '../TplLookup'; // Nutzt ab sofort das zentrale Lexikon
 export class ParameterRule implements LinterRule {
    public checkLine(line: string, rawLine: string, lineIdx: number, ctx: LinterContext, lines: string[]): void {
        let cleanLine = "";
        let inString = false;
        let stringChar = '';
        let inTripleQuote = false;
        for (let i = 0; i < line.length; i++) {
            const char = line[i];
            // 1. Single-Line Kommentare (//) ignorieren
            if (!inString && !inTripleQuote && char === '/' && line[i+1] === '/') {
                break;
            }
            // 2. TPL Triple Quotes (""" oder ''') erkennen
            if (!inString && !inTripleQuote && 
                (char === '"' || char === "'") && 
                line[i+1] === char && 
                line[i+2] === char) {
                inTripleQuote = true;
                stringChar = char;
                cleanLine += char + char + char; // Die """ behalten, damit wir die Zeile nicht komplett leeren
                i += 2; // Überspringe die nächsten zwei Zeichen
                continue;
            }
            // 3. Triple Quotes beenden
            if (inTripleQuote) {
                if (char === stringChar && line[i+1] === stringChar && line[i+2] === stringChar) {
                    inTripleQuote = false;
                    cleanLine += char + char + char;
                    i += 2;
                }
                continue; // Alles innerhalb von """ ignorieren!
            }
            // 4. Normale Strings beenden
            if (inString) {
                if (char === '\\') {
                    i++; // Escape-Sequenzen ignorieren
                } else if (char === stringChar) {
                    inString = false;
                    cleanLine += char; 
                }
                continue; // Alles innerhalb von " ignorieren!
            }
            // 5. Normale Strings starten
            if (!inString && !inTripleQuote && (char === '"' || char === "'")) {
                inString = true;
                stringChar = char;
                cleanLine += char;
                continue;
            }
            // Wenn wir hier ankommen, sind wir im echten, ausführbaren TPL-Code
            cleanLine += char;
        }
        if (cleanLine.trim().length === 0) {return;}
        // Die Definition der Funktion selbst ist kein Aufruf und wird ignoriert.
        if (/^\s*define\s+/.test(cleanLine)) {return;}
        const callRegex = /\b([a-zA-Z0-9_]+(?:\.[a-zA-Z0-9_]+)?)\s*\(/g;
        let match;
        while ((match = callRegex.exec(cleanLine)) !== null) {
            const funcName = match[1];
            const callStart = match.index;
            const parenStart = callStart + funcName.length;
            if (/^(if|elif|where|for|while|in|matches|has|subword|defined)\b/.test(funcName)) {continue;}
            let depth = 0;
            let parenEnd = -1;
            for (let i = parenStart; i < cleanLine.length; i++) {
                if (cleanLine[i] === '(') {depth++;}
                else if (cleanLine[i] === ')') {
                    depth--;
                    if (depth === 0) {
                        parenEnd = i;
                        break;
                    }
                }
            }
            if (parenEnd !== -1) {
                const paramsStr = cleanLine.substring(parenStart + 1, parenEnd).trim();
                let paramCount = 0;
                if (paramsStr.length > 0) {
                    let paramDepth = 0;
                    let commas = 0;
                    for (let i = 0; i < paramsStr.length; i++) {
                        if (paramsStr[i] === '(' || paramsStr[i] === '[') {paramDepth++;}
                        else if (paramsStr[i] === ')' || paramsStr[i] === ']') {paramDepth--;}
                        else if (paramsStr[i] === ',' && paramDepth === 0) {commas++;}
                    }
                    paramCount = commas + 1;
                }
                this.validateFunctionParams(funcName, paramCount, lineIdx, rawLine, ctx);
                this.validateReturnValue(funcName, cleanLine, lineIdx, rawLine, ctx);
            }
        }
    }
    public checkEnd(lines: string[], ctx: LinterContext): void {
        // empty
    }
    private validateFunctionParams(funcName: string, passedCount: number, lineIdx: number, rawLine: string, ctx: LinterContext) {
        const parts = funcName.split('.');
        if (parts.length > 1) {
            // Case-Insensitive Prüfung über den neuen Lookup!
            if (TplLookup.getBuiltInFunction(parts[0], parts[1])) {
                return; // Funktion existiert, Linter ist zufrieden.
            }
        }
        const signatures = workspaceIndex.getFunctionSignatures(funcName);
        if (signatures.length > 0) {
            const matches = signatures.some((sig: TplFunctionSignature) => sig.params.length === passedCount);
            if (!matches) {
                const expected = signatures[0].params.length;
                const idx = rawLine.indexOf(funcName);
                ctx.addDiag(lineIdx, Math.max(0, idx), Math.max(0, idx) + funcName.length, `Function '${funcName}' expects ${expected} parameter(s), but ${passedCount} were provided.`, vscode.DiagnosticSeverity.Warning);
            }
        } else if (parts.length > 1) {
            const idx = rawLine.indexOf(funcName);
            ctx.addDiag(lineIdx, Math.max(0, idx), Math.max(0, idx) + funcName.length, `Unknown function '${funcName}'. Please check your imports or contact the plugin provider.`, vscode.DiagnosticSeverity.Information);
        }
    }
    private validateReturnValue(funcName: string, cleanLine: string, lineIdx: number, rawLine: string, ctx: LinterContext) {
        const signatures = workspaceIndex.getFunctionSignatures(funcName);
        if (signatures.length > 0 && signatures[0].hasReturnValue) {
            const isAssigned = cleanLine.includes(':=');
            const isUsedInCondition = /\b(if|elif|while)\b/.test(cleanLine);
            if (!isAssigned && !isUsedInCondition) {
                const idx = rawLine.indexOf(funcName);
                ctx.addDiag(lineIdx, Math.max(0, idx), Math.max(0, idx) + funcName.length, `The return value of '${funcName}' is not used. Did you forget an assignment (:=)?`, vscode.DiagnosticSeverity.Warning);
            }
        }
    }
 }
--- a/src/core/rules/SyntaxRule.ts
+++ b/src/core/rules/SyntaxRule.ts
@ -0,0 +1,147 @@
 import * as vscode from 'vscode';
 import { LinterRule } from './LinterRule';
 import { LinterContext } from '../LinterContext';
 import { workspaceIndex } from '../WorkspaceIndex';
 export class SyntaxRule implements LinterRule {
    public checkLine(line: string, rawLine: string, lineIdx: number, ctx: LinterContext, lines: string[]): void {
        this.checkTabs(rawLine, lineIdx, ctx);
        let cleanLine = line.replace(/"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'/g, '""');
        const commentIdx = cleanLine.indexOf('//');
        let codePart = commentIdx !== -1 ? cleanLine.substring(0, commentIdx).trim() : cleanLine.trim();
        if (codePart.length === 0) {return;}
        // --- MULTI-LINE IMPORT HANDLING & VALIDATION ---
        if (codePart.startsWith('from ')) {
            const match = codePart.match(/^from\s+([a-zA-Z0-9_.]+)\s+import/);
            if (match) {
                ctx.inImportBlock = true;
                ctx.currentImportModule = match[1];
            }
        }
        if (ctx.inImportBlock) {
            // Remove 'from X import' and any trailing semicolons
            const importString = codePart.replace(/^from\s+[a-zA-Z0-9_.]+\s+import/, '').replace(/;$/, '');
            const imports = importString.split(',').filter(i => i.trim().length > 0);
            // Check against RAM index
            const availableItems = workspaceIndex.getDefinitionBlocksForModule(ctx.currentImportModule);
            // Only warn if we actually have the module in RAM, but the specific item is missing
            if (availableItems.length > 0) {
                for (const imp of imports) {
                    const cleanImp = imp.trim().split(/\s+/)[0]; // Trims version number (e.g. "HostToPoolMember 2.0" -> "HostToPoolMember")
                    if (cleanImp.length > 0 && !availableItems.includes(cleanImp)) {
                        const idx = rawLine.indexOf(cleanImp);
                        ctx.addDiag(lineIdx, Math.max(0, idx), Math.max(0, idx) + cleanImp.length, `The item '${cleanImp}' does not exist in module '${ctx.currentImportModule}'.`, vscode.DiagnosticSeverity.Error);
                    }
                }
            }
            // If the line ends with a semicolon, the import block is closed
            if (codePart.endsWith(';')) {
                ctx.inImportBlock = false;
                ctx.currentImportModule = "";
            }
            return; // Skip all other syntax checks for lines inside an import block
        }
        // ------------------------------------------------
        let isStructuralKeyword = /^(tpl|pattern|syncmapping|table|definitions?|define|enumeration|configuration|metadata|overview|constants|triggers|mapping|removal|body|end|on|tags|origin|author|products|publishers|tree_path|import|from)\b/.test(codePart);
        if (codePart.startsWith('"') || codePart.startsWith("'")) {
            isStructuralKeyword = true;
        }
        const isValidExecutionArea = 
            ctx.activePhaseName === 'body' || 
            ctx.activePhaseName === 'triggers' || 
            ctx.activePhaseName === 'constants' || 
            ctx.activePhaseName === 'overview' || 
            ctx.activePhaseName === 'mapping' || 
            ctx.activePhaseName === 'metadata' || 
            ctx.inModuleMetadata ||
            ctx.inBlock === 'table' || 
            ctx.inBlock === 'definitions' || 
            ctx.openDefines.length > 0;
        // 'then' and 'do' on standalone lines are legitimate code
        if (!isStructuralKeyword && !isValidExecutionArea && !/^(then|do)\b/.test(codePart)) {
            ctx.addDiag(lineIdx, 0, rawLine.length, "Executable code is not allowed here. (Allowed in: 'body', 'triggers', 'constants', 'overview', 'mapping', 'metadata', 'definitions', or 'define').", vscode.DiagnosticSeverity.Error);
        }
        this.checkBrackets(codePart, rawLine, lineIdx, ctx);
        this.checkAssignments(codePart, rawLine, lineIdx, ctx);
        this.checkSemicolons(codePart, rawLine, lineIdx, ctx, line);
    }
    public checkEnd(lines: string[], ctx: LinterContext): void {
        for (const unclosedLine of ctx.parenStack) { ctx.addDiag(unclosedLine, 0, lines[unclosedLine].length, "Opening parenthesis '(' is not closed!", vscode.DiagnosticSeverity.Error); }
        for (const unclosedLine of ctx.bracketStack) { ctx.addDiag(unclosedLine, 0, lines[unclosedLine].length, "Opening bracket '[' is not closed!", vscode.DiagnosticSeverity.Error); }
    }
    private checkTabs(rawLine: string, lineIdx: number, ctx: LinterContext) {
        const tabIndex = rawLine.indexOf('\t');
        if (tabIndex !== -1) {
            const diag = ctx.addDiag(lineIdx, tabIndex, tabIndex + 1, "Please replace tabs with spaces", vscode.DiagnosticSeverity.Warning);
            diag.code = 'invalid_tab'; 
        }
    }
    private checkBrackets(codePart: string, rawLine: string, lineIdx: number, ctx: LinterContext) {
        for (let charIdx = 0; charIdx < codePart.length; charIdx++) {
            const char = codePart[charIdx];
            if (char === '(') { ctx.parenStack.push(lineIdx); } 
            else if (char === ')') {
                if (ctx.parenStack.length > 0) { ctx.parenStack.pop(); } 
                else { ctx.addDiag(lineIdx, 0, rawLine.length, "Unexpected closing parenthesis ')'. Missing an opening parenthesis.", vscode.DiagnosticSeverity.Error); }
            }
            else if (char === '[') { ctx.bracketStack.push(lineIdx); }
            else if (char === ']') {
                if (ctx.bracketStack.length > 0) { ctx.bracketStack.pop(); }
                else { ctx.addDiag(lineIdx, 0, rawLine.length, "Unexpected closing bracket ']'. Missing an opening bracket.", vscode.DiagnosticSeverity.Error); }
            }
        }
    }
    private checkAssignments(codePart: string, rawLine: string, lineIdx: number, ctx: LinterContext) {
        if (/\b(if|elif|where)\b/.test(codePart)) { ctx.inConditionBlock = true; }
        if (codePart.includes('=') && !codePart.includes(':=') && !codePart.includes('>=') && !codePart.includes('<=')) {
            if (!ctx.inConditionBlock && ctx.parenStack.length === 0 && ctx.bracketStack.length === 0 && !/\b(matches)\b/.test(codePart)) {
                const idx = rawLine.indexOf('='); 
                if (idx !== -1) {
                    ctx.addDiag(lineIdx, idx, idx + 1, "Invalid assignment. In TPL, ':=' is used for assignments.", vscode.DiagnosticSeverity.Error);
                }
            }
        }
        if (/\b(then|do)\b/.test(codePart) || codePart.endsWith(';')) { ctx.inConditionBlock = false; }
    }
    private checkSemicolons(codePart: string, rawLine: string, lineIdx: number, ctx: LinterContext, originalTrimmedLine: string) {
        if (ctx.isClosingString) {
            if (ctx.stringNeedsSemicolon && !originalTrimmedLine.endsWith(';')) {
                ctx.addDiag(lineIdx, Math.max(0, rawLine.length - 1), rawLine.length, "Missing semicolon at the end of the assignment.", vscode.DiagnosticSeverity.Error);
            }
        } else {
            // "then" and "do" can stand alone without a semicolon requirement
            const noSemicolonNeeded = /^(pattern|syncmapping|traverse|table|enumeration|configuration|definitions?|define|metadata|overview|constants|triggers|mapping|removal|body|end\s+|if\s+|else|elif\s+|for\s+|while\s+|then\b|do\b|\/\/|\/\*|\*)/.test(codePart);
            // "in" (for loops) is a valid line break
            const continuesOnNextLine = /(,|and|or|not|\+|-|\*|\/|=|:=|matches|in)$/i.test(codePart);
            const endsWithBlockOpener = /\b(then|do)$/.test(codePart);
            if (!noSemicolonNeeded && !ctx.justOpenedString && ctx.parenStack.length === 0 && ctx.bracketStack.length === 0 && ctx.inBlock !== 'enumeration' && !ctx.inConditionBlock && !continuesOnNextLine && !endsWithBlockOpener) {
                if (codePart.length > 0 && !codePart.endsWith(';') && !codePart.endsWith('{') && !codePart.endsWith(',')) {
                    ctx.addDiag(lineIdx, Math.max(0, rawLine.length - 1), rawLine.length, "Missing semicolon at the end of the statement.", vscode.DiagnosticSeverity.Error);
                }
            }
        }
    }
 }
--- a/src/data/GeneratedTplBuiltIns.ts
+++ b/src/data/GeneratedTplBuiltIns.ts
--- a/src/data/TplBuiltIns.ts
+++ b/src/data/TplBuiltIns.ts
@ -0,0 +1,244 @@
 export interface TplBuiltInMethod {
    description: string;
    snippets: string[];
 }
 export const tplBuiltIns: Record<string, Record<string, TplBuiltInMethod>> = {
    "built_in_globals": {
        "datatype": {
            snippets: ["${1:item}"],
            description: `Returns a string indicating the type of the item.\n\nPossible return values are:\n"node"\n"relationship"\n"text"\n"boolean"\n"number"\n"float"\n"list"\n"table"\n"none"\n"void"\n"datetime"\n"nodeset"\n"unknown" (used for anything else)`
        },
        "size": {
            snippets: ["${1:collection}"],
            description: `Returns the number of items in the collection.\n\nWhere the collection is a list, or a set of nodes retrieved with a search expression.\nWhere the collection is a string, the number of characters is returned.\nTo determine the type of the collection, you can use the datatype function.`
        }
    },
    "log": {
        "debug": { snippets: ["${1:output}"], description: `Log the given message with a debug level message.` },
        "info": { snippets: ["${1:output}"], description: `Log the given message with an info level message.` },
        "warn": { snippets: ["${1:output}"], description: `Log the given message with a warn level message.` },
        "error": { snippets: ["${1:output}"], description: `Log the given message with an error level message.` },
        "critical": { snippets: ["${1:output}"], description: `Log the given message with a critical level message.` }
    },
    "text": {
        "lower": { snippets: ["${1:input}"], description: `Returns the lower-cased version of the string argument.` },
        "upper": { snippets: ["${1:input}"], description: `Returns the upper-cased version of the string argument.` },
        "toNumber": {
            snippets: ["${1:input}", "${1:input},${2:base}"],
            description: `Converts its string argument into a number. By default, the number is treated as a base 10 value; if the optional base is provided, the number is treated as being in the specified base. Bases from 2 to 36 are supported.`
        },
        "replace": {
            snippets: ["${1:input}, ${2:old},${3:new}"],
            description: `Returns a modified version of the string formed by replacing all occurrences of the string old with new.`
        },
        "join": {
            snippets: ["${1:list},${2:separator}"],
            description: `Returns a string containing all items in a list of strings joined with the specified separator.`
        },
        "split": {
            snippets: ["${1:input}", "${1:input},${2:separator}"],
            description: `Returns a list consisting of portions of the string split according to the separator string, where specified.`
        },
        "strip": {
            snippets: ["${1:input}", "${1:input},${2:characters}"],
            description: `Strips unwanted characters from the start and end of the given string.`
        },
        "leftStrip": {
            snippets: ["${1:input}", "${1:input},${2:characters}"],
            description: `Equivalent to text.strip, but only strips from the left side of the string.`
        },
        "rightStrip": {
            snippets: ["${1:input}", "${1:input},${2:characters}"],
            description: `Equivalent to text.strip, but only strips from the right side of the string.`
        },
        "hash": { snippets: ["${1:input}"], description: `Returns a hashed form of the string, generated with the MD5 hash algorithm.` },
        "ordinal": { snippets: ["${1:input}"], description: `Returns the ordinal value of the string argument. The string must be one character in length.` }
    },
    "number": {
        "toChar": { snippets: ["${1:number}"], description: `Converts the integer number in the ASCII range to a character.` },
        "toText": {
            snippets: ["${1:number}", "${1:number}, ${2:base}", "${1:number}, ${2:base},${3:width}"],
            description: `Converts the integer number to a text form. The default is to use the base 10 representation. If the optional base argument is given, conversion uses that base instead.`
        },
        "range": { snippets: ["${1:number}"], description: `Generate a list containing 0 to number - 1.` }
    },
    "regex": {
        "extract": {
            snippets: ["${1:string}, ${2:expression}", "${1:string}, ${2:expression},${3:substitution}", "${1:string},${2:expression}, ${3:substitution},${4:no_match}"],
            description: `Returns the result of extracting the regular expression from the string.`
        },
        "extractAll": { snippets: ["${1:string},${2:pattern}"], description: `Returns a list containing all the non-overlapping matches of the pattern in the string.` },
        "replace": {
            snippets: ["${1:string}, ${2:pattern},${3:replacement}", "${1:string},${2:pattern}, ${3:replacement}, count:=${4:0}"],
            description: `Return a string with all non-overlapping matches of pattern replaced by replacement.`
        },
        "escape": { snippets: ["${1:string}"], description: `Returns a string with regex special characters suitably escaped.` }
    },
    "xpath": {
        "openDocument": { snippets: ["${1:string}"], description: `Returns the DOM object resulting from parsing the XML string.` },
        "evaluate": {
            snippets: ["${1:sourceXML}, ${2:expression}", "${1:sourceXML}, ${2:expression},${3:namespaces}", "${1:sourceXML},${2:expression}, ${3:namespaces},${4:return_elements}"],
            description: `Returns the result of evaluating the XPath expression against the XML string.`
        },
        "closeDocument": { snippets: ["${1:dom_object}"], description: `Closes an XML document opened with xpath.openDocument.` }
    },
    "table": {
        "remove": { snippets: ["${1:table},${2:key}"], description: `Removes the specified key from the specified table.` },
        "get": {
            snippets: ["${1:table}, ${2:key}", "${1:table}, ${2:key}, default_val:=${3:none}"],
            description: `Returns the key from table if it exists, or if it does not exist, returns the specified default_val.`
        },
        "keys": { snippets: ["${1:table}"], description: `Returns a list of the keys in the table.` },
        "values": { snippets: ["${1:table}"], description: `Returns a list of the values in the table.` }
    },
    "Future": {
        "runCommand": {
            snippets: ["${1:target}, ${2:command},${3:path_to_command}"],
            description: `Returns a DiscoveredCommandResult node containing the result of running the specified command. Enables command paths to be restricted.`
        }
    },
    "discovery": {
        "fileGet": {
            snippets: ["${1:target}, ${2:filename}", "${1:target}, ${2:filename}, container_context:=${3:true}", "${1:target},${2:filename}, container_context:=${3:true}, win64_redirect:=${4:true}"],
            description: `Retrieves the specified file.\n\nThe function takes the following parameters:\n\ntarget: a node used to identify the discovery target.\nfilename: the name of the file on which to return information.\ncontainer_context: an optional flag to specify how container context is interpreted.\nwin64_redirect: an optional flag which enables you to specify whether the search for the file should take place in the 32 bit directory if not found in the 64 bit directory.\n\nReturns a DiscoveredFile node.`
        },
        "fileInfo": {
            snippets: ["${1:target}, ${2:filename}", "${1:target}, ${2:filename}, container_context:=${3:true}", "${1:target},${2:filename}, container_context:=${3:true}, win64_redirect:=${4:true}"],
            description: `Retrieves information about the specified file, but not the file content. This information is useful if the file is a binary file or particularly large.\n\nReturns a DiscoveredFile node with no content attribute.`
        },
        "listDirectory": {
            snippets: ["${1:target}, ${2:path}", "${1:target}, ${2:path}, container_context:=${3:true}", "${1:target},${2:path}, container_context:=${3:true}, win64_redirect:=${4:true}"],
            description: `Retrieves the directory listing of the directory specified by the path on the specified target.\n\nThe function takes the following parameters:\n\ntarget, where target is:\na node used to identify the discovery target, either a directly discovered data node, or a Host node. Or,\na data source against which the request is performed. See also, discovery-dataSource.\npath – the path to the directory on which to return information. You cannot use wildcards in the path. \ncontainer_context is an optional flag to specify how container context is interpreted for the command. When a pattern triggers on a DiscoveredProcess or RuntimeEnvironment within a container, or on a ContainedSoftwareInstance or SoftwareContainer node, then the requests are executed in the container. This behavior is the default; container_context = true. However, on occasions where you want to run the request on the host, for example, you might be examining the /proc file system, you must specify container_context = false. When the pattern triggers outside a container, then there is no container context, and the flag has no effect.\nwin64_redirect is an optional flag which enables you to specify whether the search for the file should take place in the 32 bit directory if not found in the 64 bit directory. TRUE means search the 32 bit directory, FALSE means do not search the 32 bit directory if the file is not found in the 64 bit directory. The default is TRUE.\nReturns a list of Discovered Directory Entry nodes.\n\n64 bit Windows hosts have the following system directories for holding executables, DLLs, and so forth:\n\n%windir%\\system32 — 64 bit executables and DLLs\n%windir%\\SysWOW64 — 32 bit executables and DLLs\nPaths that do not start with %windir%\\system32 or %systemroot%\\system32 are never checked for redirection.\n\nOn non-Windows and 32 bit Windows systems win64_redirect has no effect.\n\nIf the call fails, it returns none and records the failure reason in the Directory Listing node.\n\nRestrictions\nOn Windows systems, owner and group information is not recovered.\nGroup names which include spaces are not supported.\nConfig.sys is not listed as a system file.\nDirectory Listing nodes are not created for empty Windows directories.`
        },
        "getNames": { snippets: ["${1:target},${2:ip_address}"], description: `Performs a DNS lookup on the IP address and returns a list of FQDN strings.` },
        "lookupAddresses": { snippets: ["${1:target},${2:name}"], description: `Performs a DNS lookup on the supplied DNS resolvable name and returns a list of IP addresses.` },
        "listRegistry": {
            snippets: ["${1:target}, ${2:key_path}", "${1:target}, ${2:key_path}, win64_redirect:=${3:true}"],
            description: `Returns a list of the registry entries of the registry key specified by the key_path.`
        },
        "registryKey": {
            snippets: ["${1:target}, ${2:key}", "${1:target}, ${2:key}, win64_redirect:=${3:true}"],
            description: `Retrieves a registry key from a Windows computer.\nReturns a DiscoveredRegistryValue node.`
        },
        "wmiQuery": {
            snippets: ["${1:target}, ${2:query},${3:namespace}"],
            description: `Performs a WMI query on a Windows computer.\nReturns a list of DiscoveredWMI nodes.`
        },
        "wbemQuery": {
            snippets: ["${1:target}, ${2:class_name},${3:namespace}", "${1:target},${2:class_name}, ${3:properties},${4:namespace}"],
            description: `Performs a WBEM query on the target and returns a list of DiscoveredWBEM DDD nodes.`
        },
        "wbemEnumInstances": {
            snippets: ["${1:target}, ${2:class_name},${3:properties}, ${4:namespace}, filter_locally:=${5:false}"],
            description: `Performs a WBEM query on the target and returns a list of DiscoveredWBEMInstance DDD nodes.`
        },
        "runCommand": {
            snippets: ["${1:target}, ${2:command},${3:restrict_paths}, ${4:dialect}", "${1:target}, ${2:command},${3:restrict_paths}, ${4:dialect}, container_context:=${5:true}"],
            description: `Returns a DiscoveredCommandResult node containing the result of running the specified command.`
        },
        "runPowerShell": {
            snippets: ["${1:target}, ${2:script},${3:restrict_paths}"],
            description: `Returns a DiscoveredCommandResult node containing the result of running the specified PowerShell script.`
        },
        "snmpGet": {
            snippets: ["${1:target}, ${2:oid_table}", "${1:target}, ${2:oid_table},${3:binary_oid_list}"],
            description: `Performs an SNMP query on the target and returns a DiscoveredSNMP node.`
        },
        "snmpGetTable": {
            snippets: ["${1:target}, ${2:table_oid},${3:column_table}", "${1:target},${2:table_oid}, ${3:column_table},${4:binary_oid_list}"],
            description: `Performs an SNMP query that returns a table on the target. Returns a list of DiscoveredSNMPRow nodes or none if the SNMP query failed.`
        },
        "scan": {
            snippets: ["${1:target},${2:company}, ${3:outpost_id},${4:scope}"],
            description: `Adds an open scan for the given target and returns a count of the number of endpoints included in the open scan.`
        },
        "process": { snippets: ["${1:source}"], description: `Returns the process node corresponding to the source node.` },
        "children": { snippets: ["${1:process}"], description: `Returns a list of the child processes for the given DiscoveredProcess node.` },
        "descendents": { snippets: ["${1:process}"], description: `Returns a list consisting of the children of the given DiscoveredProcess node, and recursively all of the children's children.` },
        "parent": { snippets: ["${1:process}"], description: `Returns the parent process for the given DiscoveredProcess node.` },
        "allProcesses": { snippets: ["${1:source}"], description: `Returns a list of all processes corresponding to the directly discovered data source node.` },
        "access": { snippets: ["${1:source}"], description: `Returns the Discovery Access node for the source DDD node, if given.` },
        "startTime": { snippets: ["${1:source}"], description: `Returns the start time of the scan which discovered the source DDD node.` }
    },
    "binary": {
        "toHexString": { snippets: ["${1:value}"], description: `Returns the given binary value as a hex string.` },
        "toIPv4": { snippets: ["${1:value}"], description: `Returns the given binary value as the text representation of an IPv4 address.` },
        "toIPv4z": { snippets: ["${1:value}"], description: `Returns the given binary value as the text representation of an IPv4 address with a zone index.` },
        "toIPv6": { snippets: ["${1:value}"], description: `Returns the given binary value as the text representation of a canonical IPv6 address.` },
        "toIPv6z": { snippets: ["${1:value}"], description: `Returns the given binary value as the text representation of a canonical IPv6 address with zone index.` },
        "toMACAddress": { snippets: ["${1:value}"], description: `Returns the given binary value as the text representation of a MAC address.` },
        "toValue": { snippets: ["${1:data},${2:format}"], description: `Converts the given binary value into the specified format.` },
        "toWWN": { snippets: ["${1:value}"], description: `Returns the given binary value as the text representation of a WWN value.` }
    },
    "json": {
        "encode": { snippets: ["${1:value}"], description: `Converts value to a JSON encoded string. Where value is a string, table, or a list including nested structures.` },
        "decode": { snippets: ["${1:value}"], description: `Decodes a JSON encoded string and returns a structure containing a number, boolean, null, string, table or list including nested structures.` }
    },
    "jmespath": {
        "evaluate": { snippets: ["${1:source},${2:expression}"], description: `Returns the https://jmespath.org/ evaluation for the expression given a source table or list.` }
    },
    "yaml": {
        "encode": { snippets: ["${1:object}"], description: `Converts the given object into a YAML-encoded string.` },
        "decode": { snippets: ["${1:value}"], description: `Converts the given YAML encoded string into an object.` },
        "decodeAll": { snippets: ["${1:value}"], description: `Converts the given YAML encoded string into a list of objects.` }
    },
    "list": {
        "append": { snippets: ["${1:list},${2:value}"], description: `Appends an item to a specified list.` },
        "sorted": { snippets: ["${1:items}", "${1:items}, reverse:=${2:false}"], description: `Returns a sorted copy of items list, leaving the items unchanged. If reverse is true, sorts in reverse order.` }
    },
    "model": {
        "addContainment": { snippets: ["${1:container},${2:containees}"], description: `Adds the containees to the container by creating suitable relationships between the nodes.` },
        "setContainment": { snippets: ["${1:container},${2:containees}"], description: `Equivalent to addContainment, except that at the end of the pattern body, any relationships to contained nodes that have not been confirmed are removed.` },
        "destroy": { snippets: ["${1:node}"], description: `Destroy the specified node or relationship in the model.` },
        "withdraw": { snippets: ["${1:node},${2:attribute}"], description: `Removes the named attribute from the node.` },
        "setRemovalGroup": { snippets: ["${1:node}", "${1:node},${2:name}"], description: `Add the specified node or nodes to a named removal group.` },
        "anchorRemovalGroup": { snippets: ["${1:node}", "${1:node},${2:name}"], description: `Specify an anchor node for a named removal group.` },
        "suppressRemovalGroup": { snippets: ["${1:name}"], description: `Suppress removal of the named removal group.` },
        "host": { snippets: ["${1:node}"], description: `Returns the Host node corresponding to the given node.` },
        "hosts": { snippets: ["${1:node}"], description: `Returns a list of all the Host nodes corresponding to the given node.` },
        "findPackages": { snippets: ["${1:node},${2:regexes}"], description: `Traverses from the node, and returns a set of all Package nodes that have names matching the provided list of regular expressions.` },
        "addDisplayAttribute": { snippets: ["${1:node},${2:value}"], description: `Adds a named attribute, or a list of named attributes to the additional attributes displayed in a node view.` },
        "removeDisplayAttribute": { snippets: ["${1:node},${2:value}"], description: `Removes a named attribute, or a list of named attributes from the additional attributes displayed in a node view.` },
        "kind": { snippets: ["${1:node}"], description: `Returns the node kind corresponding to the given node.` },
        "confirm": { snippets: ["${1:node}"], description: `Sends a confirmed event for the node.` },
        "findCandidate": { snippets: ["${1:kind},${2:data}"], description: `Finds a candidate node of a kind that matches table data.` },
        "findCandidates": { snippets: ["${1:kind}, ${2:data},${3:limit}"], description: `Finds ranked candidates.` },
        "publish": { snippets: ["${1:node},${2:auto_rels}"], description: `Takes a node of kind ModelDefinition and publishes it, creating a BusinessService, TechnicalService or BusinessApplicationInstance node.` },
        "unpublish": { snippets: ["${1:node}"], description: `Takes a node of kind ModelDefinition that has been published, and unpublishes it.` }
    },
    "related": {
        "host": { snippets: ["${1:node}"], description: `Returns the Host node corresponding to the given node.` },
        "detailContainer": { snippets: ["${1:node}"], description: `Returns the Software Component, Software Instance, or Business Application Instance node containing the given node.` },
        "hostingNode": { snippets: ["${1:fallback_kind},${2:attributes}"], description: `Returns a Host or Cluster node that is associated with the node that triggered the pattern.` }
    },
    "mail": {
        "send": {
            snippets: ["${1:recipients},${2:subject}, ${3:message}", "${1:recipients}, ${2:subject},${3:message}, ${4:cc_addrs}", "${1:recipients}, ${2:subject},${3:message}, ${4:cc_addrs},${5:bcc_addrs}"],
            description: `Sends an email.`
        }
    },
    "time": {
        "current": { snippets: [""], description: `Returns an internal datetime object representing the current UTC time.` },
        "delta": { snippets: ["${1:days},${2:hours}, ${3:minutes},${4:seconds}"], description: `Creates a time delta that can be added to or subtracted from a time represented by an internal datetime object.` },
        "parseLocal": { snippets: ["${1:string}"], description: `Converts a string representing a local time into an internal UTC datetime object.` },
        "parseUTC": { snippets: ["${1:string}"], description: `Takes a UTC time string and converts it into an internal datetime object.` },
        "formatLocal": { snippets: ["${1:datetime}", "${1:datetime},${2:format}"], description: `Formats an internal datetime object into a human-readable string. Converts the time into the appliance's timezone.` },
        "formatUTC": { snippets: ["${1:datetime}", "${1:datetime},${2:format}"], description: `Formats an internal datetime object into a human-readable string. Performs no timezone conversion.` },
        "toTicks": { snippets: ["${1:datetime}"], description: `Converts an internal datetime object (UTC) to ticks.` },
        "fromTicks": { snippets: ["${1:ticks}"], description: `Converts ticks to an internal datetime object (UTC).` },
        "deltaFromTicks": { snippets: ["${1:ticks}"], description: `Converts ticks into a time delta.` }
    },
    "inference": {
        "associate": { snippets: ["${1:inferred_node},${2:associate}"], description: `Create associate inference relationship(s) from the specified node(s) to the inferred node.` },
        "contributor": { snippets: ["${1:inferred_node}, ${2:contributor},${3:contributes}"], description: `Create contributor inference relationship(s).` },
        "primary": { snippets: ["${1:inferred_node}, ${2:evidence}", "${1:inferred_node}, ${2:evidence}, replace:=${3:false}"], description: `Create or replace primary inference relationship(s).` },
        "relation": { snippets: ["${1:inferred_relationship},${2:source}"], description: `Create relation inference relationship(s) from the specified node(s) to the inferred relationship.` },
        "withdrawal": { snippets: ["${1:inferred_node}, ${2:evidence},${3:withdrawn}"], description: `Create withdrawal inference relationship(s).` },
        "destruction": { snippets: ["${1:destroyed_node},${2:source}"], description: `When destroying a node, indicate that the source node was responsible for its destruction.` }
    },
    "system": {
        "getOption": { snippets: ["${1:option_name}"], description: `Takes the name of a BMC Helix Discovery system option and returns the value.` },
        "cmdbSync": { snippets: ["${1:nodes}"], description: `Adds the given root node or list of root nodes to the CMDB synchronization queue.` }
    }
 };
--- a/src/extension.ts
+++ b/src/extension.ts
@ -1,261 +1,71 @@
 import * as vscode from 'vscode';
-import { TplCodeActionProvider } from './TplCodeActionProvider';
+import { validateTplDocument } from './core/TplLinter';
-import { TplDocumentFormatter } from './TplDocumentFormatter';
+import { TplCodeActionProvider } from './providers/TplCodeActionProvider';
-
+import { TplDocumentFormatter } from './providers/TplDocumentFormatter';
-// --- Konstanten ---
+import { TplCompletionProvider } from './providers/TplCompletionProvider';
-const SUPPORTED_TPL_VERSION = 23; // TPL 1.23
+import { TplHoverProvider } from './providers/TplHoverProvider';
-const warnedDocuments = new Set<string>();
+import { workspaceIndex } from './core/WorkspaceIndex'; 
-
+import { TplDefinitionProvider } from './providers/TplDefinitionProvider';
 // Erlaubte Phasen in einem Pattern (strikte Reihenfolge laut BMC TPL)
 enum PatternPhase {
    None = 0,
    Metadata = 1,
    Overview = 2,
    Constants = 3,
    Triggers = 4,
    Body = 5
 }
 export function activate(context: vscode.ExtensionContext) {
    // 1. Diagnostic Collection (Der Scanner für rote/gelbe Wellenlinien)
    const diagnosticCollection = vscode.languages.createDiagnosticCollection('tpl-scanner');
    context.subscriptions.push(diagnosticCollection);
-    // 2. Events registrieren (Ausführen beim Öffnen und Ändern)
+    // LIVE INDEXING & LINTING
-    vscode.workspace.onDidOpenTextDocument(doc => validateTplDocument(doc, diagnosticCollection));
+    vscode.workspace.onDidOpenTextDocument(doc => {
-    vscode.workspace.onDidChangeTextDocument(event => validateTplDocument(event.document, diagnosticCollection));
+        if (doc.languageId === 'tpl') {
            workspaceIndex.updateFile(doc.uri, doc.getText());
            validateTplDocument(doc, diagnosticCollection);
        }
    });
-    // 3. Quick-Fix Provider (Code Actions für Glühbirnen-Menü) registrieren
+    vscode.workspace.onDidChangeTextDocument(event => {
-    context.subscriptions.push(
+        if (event.document.languageId === 'tpl') {
-        vscode.languages.registerCodeActionsProvider('tpl', new TplCodeActionProvider(), {
+            workspaceIndex.updateFile(event.document.uri, event.document.getText());
-            providedCodeActionKinds: [vscode.CodeActionKind.QuickFix]
+            validateTplDocument(event.document, diagnosticCollection);
-        })
+        }
-    );
+    });
-    // 4. Format Document Provider (Auto-Aufräumen mit Shift+Alt+F)
+    // Aufräumen, wenn Dateien gelöscht werden
-    context.subscriptions.push(
+    vscode.workspace.onDidDeleteFiles(event => {
-        vscode.languages.registerDocumentFormattingEditProvider('tpl', new TplDocumentFormatter())
+        for (const uri of event.files) {
-    );
+            workspaceIndex.removeFile(uri);
        }
    });
    vscode.workspace.onDidChangeConfiguration(e => {
        if (e.affectsConfiguration('tpl')) {
            scanWorkspace(diagnosticCollection);
        }
    });
    // Provider registrieren
    context.subscriptions.push(vscode.languages.registerCodeActionsProvider('tpl', new TplCodeActionProvider(), { providedCodeActionKinds: [vscode.CodeActionKind.QuickFix] }));
    context.subscriptions.push(vscode.languages.registerDocumentFormattingEditProvider('tpl', new TplDocumentFormatter()));
    context.subscriptions.push(vscode.languages.registerCompletionItemProvider('tpl', new TplCompletionProvider(), '.'));
    context.subscriptions.push(vscode.languages.registerHoverProvider('tpl', new TplHoverProvider()));
    context.subscriptions.push(vscode.languages.registerDefinitionProvider('tpl', new TplDefinitionProvider()));
    context.subscriptions.push(vscode.commands.registerCommand('tpl.scanWorkspace', () => {
        scanWorkspace(diagnosticCollection);
        vscode.window.showInformationMessage("TPL: Workspace-Scan gestartet.");
    }));
    // Initialer Scan beim Start
    scanWorkspace(diagnosticCollection);
 }
-function validateTplDocument(document: vscode.TextDocument, collection: vscode.DiagnosticCollection) {
+// Füttert RAM und Linter
-    if (document.languageId !== 'tpl') { return; }
+async function scanWorkspace(collection: vscode.DiagnosticCollection) {
    const files = await vscode.workspace.findFiles('**/*.tpl', '**/node_modules/**');
-    const diagnostics: vscode.Diagnostic[] = [];
+    for (const file of files) {
-    const text = document.getText();
+        const doc = await vscode.workspace.openTextDocument(file);
    const lines = text.split('\n');
-    let tplVersion = 10;
+        // ZUERST in den RAM laden...
-    let toleranceMode = false;
+        workspaceIndex.updateFile(doc.uri, doc.getText());
    let hasModuleDef = false;
-    // --- State Machine Variablen ---
+        // ... DANN linten
-    let inBlock: 'none' | 'pattern' | 'table' | 'definitions' = 'none';
+        validateTplDocument(doc, collection);
    let currentPatternPhase: PatternPhase = PatternPhase.None;
    let inMultiLineComment = false;
    // State Tracking für Quick-Fixes
    let currentPatternName = "";
    let foundMetadata = { author: false, publisher: false, origin: false, tree_path: false };
    let metadataBlockLine = -1;
    let bodyLineCount = 0;
    // --- 1. Versions-Check im Header ---
    const versionMatch = text.match(/tpl\s+1\.(\d+)\s+module/);
    if (versionMatch) {
        tplVersion = parseInt(versionMatch[1], 10);
        if (tplVersion > SUPPORTED_TPL_VERSION) {
            toleranceMode = true;
            if (!warnedDocuments.has(document.uri.toString())) {
                vscode.window.showInformationMessage(`TPL 1.${tplVersion} erkannt. Linter läuft im Toleranz-Modus (Fehler werden zu Warnungen).`);
                warnedDocuments.add(document.uri.toString());
            }
        }
    }
    function addDiag(lineIdx: number, start: number, end: number, msg: string, severity: vscode.DiagnosticSeverity): vscode.Diagnostic {
        if (toleranceMode && severity === vscode.DiagnosticSeverity.Error) {
            severity = vscode.DiagnosticSeverity.Warning;
        }
        const diag = new vscode.Diagnostic(new vscode.Range(lineIdx, start, lineIdx, end), msg, severity);
        diagnostics.push(diag);
        return diag; 
    }
    // --- 2. Der Haupt-Scanner (Zeile für Zeile) ---
    for (let i = 0; i < lines.length; i++) {
        const rawLine = lines[i];
        const line = rawLine.trim();
        // --- Tab-Check (Strikte 3-Spaces-Regel) ---
        const tabIndex = rawLine.indexOf('\t');
        if (tabIndex !== -1) {
            const diag = addDiag(
                i, 
                tabIndex, 
                rawLine.length, 
                "Tabs sind hier nicht erlaubt! Bitte nutze exakt 3 Spaces für Einrückungen. (Tipp: Mit 'Alt + Shift' + Mausklick/Pfeiltasten kannst du mehrere Zeilen gleichzeitig markieren und korrigieren).", 
                vscode.DiagnosticSeverity.Warning
            );
            diag.code = 'invalid_tab'; 
        }
        // Kommentare überspringen (aber Regex für Semikolon-Check braucht MultiLine-Info)
        if (line.startsWith('//')) { continue; }
        if (line.startsWith('/*')) { inMultiLineComment = true; continue; }
        if (inMultiLineComment) { 
            if (line.includes('*/')) { inMultiLineComment = false; }
            continue; 
        }
        if (line.length === 0) { continue; }
        // --- Semikolon-Check ---
        const noSemicolonNeeded = /^(pattern|table|metadata|overview|constants|triggers|body|end\s+|if\s+|else|elif\s+|for\s+|while\s+|\/\/|\/\*|\*)/;
        if (!noSemicolonNeeded.test(line)) {
            if (!line.endsWith(';') && !line.endsWith('{') && !line.endsWith(',')) {
                addDiag(i, rawLine.length - 1 < 0 ? 0 : rawLine.length - 1, rawLine.length, "Fehlendes Semikolon am Ende der Anweisung.", vscode.DiagnosticSeverity.Error);
            }
        }
        // Modul-Definition prüfen (Muss als Erstes stehen)
        if (!hasModuleDef) {
            if (line.startsWith('tpl ')) {
                hasModuleDef = true;
            } else {
                addDiag(i, 0, rawLine.length, "Jede Datei muss mit 'tpl 1.x module <name>;' beginnen.", vscode.DiagnosticSeverity.Error);
                hasModuleDef = true; 
            }
        }
        // --- Block-Einstiege (Pattern & Table) ---
        if (line.startsWith('pattern ')) {
            if ((inBlock as string) !== 'none') { addDiag(i, 0, 7, "Ein Pattern kann nicht innerhalb eines anderen Blocks deklariert werden.", vscode.DiagnosticSeverity.Error); }
            inBlock = 'pattern';
            currentPatternPhase = PatternPhase.None;
            const nameMatch = line.match(/pattern\s+([a-zA-Z0-9_]+)\s+\d+\.\d+/);
            if (nameMatch) {
                currentPatternName = nameMatch[1];
            } else {
                addDiag(i, 0, rawLine.length, "Ungültige Pattern-Deklaration. Erwartet: 'pattern <Name> <Version>'", vscode.DiagnosticSeverity.Error);
            }
            foundMetadata = { author: false, publisher: false, origin: false, tree_path: false };
            metadataBlockLine = -1;
            bodyLineCount = 0;
            continue;
        }
        if (line.startsWith('table ')) {
            if ((inBlock as string) !== 'none') { addDiag(i, 0, 5, "Eine Tabelle kann nicht innerhalb eines anderen Blocks deklariert werden.", vscode.DiagnosticSeverity.Error); }
            inBlock = 'table';
            if (!line.match(/table\s+[a-zA-Z0-9_]+\s+\d+\.\d+/)) {
                addDiag(i, 0, rawLine.length, "Ungültige Tabellen-Deklaration. Erwartet: 'table <Name> <Version>'", vscode.DiagnosticSeverity.Error);
            }
            continue;
        }
        // --- Innerhalb eines Patterns ---
        if ((inBlock as string) === 'pattern') {
            const checkPhase = (phaseName: string, phaseEnum: PatternPhase) => {
                if (line.startsWith(phaseName)) {
                    if ((currentPatternPhase as PatternPhase) >= phaseEnum) {
                        addDiag(i, 0, phaseName.length, `'${phaseName}' Block ist hier nicht erlaubt. Die Reihenfolge ist: metadata -> overview -> constants -> triggers -> body.`, vscode.DiagnosticSeverity.Error);
                    }
                    if ((currentPatternPhase as PatternPhase) === PatternPhase.Metadata && phaseEnum > PatternPhase.Metadata) {
                        const missing = Object.keys(foundMetadata).filter(k => !(foundMetadata as any)[k]);
                        if (missing.length > 0 && metadataBlockLine !== -1) {
                            const diag = addDiag(metadataBlockLine, 0, 8, `Fehlende Pflicht-Metadaten: ${missing.join(', ')}`, vscode.DiagnosticSeverity.Error);
                            diag.code = 'missing_metadata'; 
                        }
                    }
                    currentPatternPhase = phaseEnum;
                    if (phaseEnum === PatternPhase.Metadata) { metadataBlockLine = i; }
                }
            };
            checkPhase('metadata', PatternPhase.Metadata);
            checkPhase('overview', PatternPhase.Overview);
            checkPhase('constants', PatternPhase.Constants);
            checkPhase('triggers', PatternPhase.Triggers);
            checkPhase('body', PatternPhase.Body);
            if ((currentPatternPhase as PatternPhase) === PatternPhase.Metadata) {
                if (line.startsWith('author ')) { foundMetadata.author = true; }
                if (line.startsWith('publisher ')) { foundMetadata.publisher = true; }
                if (line.startsWith('origin ')) { foundMetadata.origin = true; }
                if (line.startsWith('tree_path ')) { foundMetadata.tree_path = true; }
            }
            if ((currentPatternPhase as PatternPhase) === PatternPhase.Body && !line.startsWith('body')) {
                bodyLineCount++;
                if (bodyLineCount === 1) {
                    const expectedLog = `log.debug("Pattern start ${currentPatternName}");`;
                    if (!line.includes(`log.debug("Pattern start ${currentPatternName}`)) {
                        const diag = addDiag(i, 0, rawLine.length, `Body muss mit dem Log-Statement beginnen: ${expectedLog}`, vscode.DiagnosticSeverity.Error);
                        diag.code = 'missing_log_start'; 
                        diag.source = expectedLog;       
                    }
                }
            }
        }
        // --- Innerhalb einer Tabelle ---
        if ((inBlock as string) === 'table') {
            if (!line.startsWith('end ') && !line.includes('table ')) {
                if (!line.includes('->') && !line.includes(':=')) {
                    addDiag(i, 0, rawLine.length, "Ungültiger Tabelleneintrag. Nutze '[\"Key\"] -> \"Value\";' oder 'default := \"Value\";'", vscode.DiagnosticSeverity.Error);
                }
            }
        }
        // --- Allgemeine Syntax-Checks ---
        const eqMatch = rawLine.match(/(?<![<>=!])=(?![=])/); 
        if (eqMatch && eqMatch.index) {
            if (!line.includes('"') && !line.includes("'")) {
                addDiag(i, eqMatch.index, eqMatch.index + 1, "Zuweisung in TPL erfolgt mit ':=', nicht mit '='. '=' ist für Vergleiche.", vscode.DiagnosticSeverity.Error);
            }
        }
        if (line.includes('?') && line.includes(':')) {
            if (tplVersion < 15) {
                addDiag(i, 0, rawLine.length, `Ternärer Operator (? :) erfordert mindestens TPL 1.15 (Aktuell: 1.${tplVersion}).`, vscode.DiagnosticSeverity.Error);
            }
        }
        const streamMatch = rawLine.match(/\bstream\b/);
        if (streamMatch && streamMatch.index !== undefined) {
            if (tplVersion < 20) {
                addDiag(i, streamMatch.index, streamMatch.index + 6, `Das 'stream'-Keyword erfordert mindestens TPL 1.20.`, vscode.DiagnosticSeverity.Error);
            }
        }
        const notInMatch = rawLine.match(/\bnot\s+in\b/);
        if (notInMatch && notInMatch.index !== undefined) {
            if (tplVersion < 18) {
                 addDiag(i, notInMatch.index, notInMatch.index + 6, `'not in' erfordert mindestens TPL 1.18.`, vscode.DiagnosticSeverity.Error);
            }
        }
        // --- Block-Ausstiege ---
        if (line.startsWith('end pattern')) {
            if ((inBlock as string) !== 'pattern') {
                addDiag(i, 0, 11, "'end pattern' gefunden, aber es wurde kein Pattern gestartet.", vscode.DiagnosticSeverity.Error);
            } else if ((currentPatternPhase as PatternPhase) < PatternPhase.Body) {
                addDiag(i, 0, 11, "Dem Pattern fehlt ein 'body'-Block.", vscode.DiagnosticSeverity.Error);
            }
            inBlock = 'none';
        }
        else if (line.startsWith('end table')) {
            if ((inBlock as string) !== 'table') {
                addDiag(i, 0, 9, "'end table' gefunden, aber es wurde keine Tabelle gestartet.", vscode.DiagnosticSeverity.Error);
            }
            inBlock = 'none';
        }
    }
    collection.set(document.uri, diagnostics);
 }
--- a/src/providers/TplCodeActionProvider.ts
+++ b/src/providers/TplCodeActionProvider.ts
@ -0,0 +1,43 @@
 import * as vscode from 'vscode';
 import { TplQuickFix } from './actions/TplQuickFix';
 import { TabFix } from './actions/TabFix';
 import { LogFix } from './actions/LogFix';
 import { MetadataFix } from './actions/MetadataFix';
 export class TplCodeActionProvider implements vscode.CodeActionProvider {
    private fixes: Map<string, TplQuickFix> = new Map();
    constructor() {
        // Hier werden alle Quick Fixes registriert
        const availableFixes: TplQuickFix[] = [
            new TabFix(),
            new LogFix(),
            new MetadataFix()
        ];
        for (const fix of availableFixes) {
            this.fixes.set(fix.diagnosticCode, fix);
        }
    }
    public provideCodeActions(
        document: vscode.TextDocument, 
        range: vscode.Range | vscode.Selection, 
        context: vscode.CodeActionContext, 
        token: vscode.CancellationToken
    ): vscode.CodeAction[] {
        const actions: vscode.CodeAction[] = [];
        // Prüfen, ob für die aktuellen Fehler (Diagnostics) ein Fix existiert
        for (const diagnostic of context.diagnostics) {
            const code = diagnostic.code;
            if (typeof code === 'string' && this.fixes.has(code)) {
                const fixLogic = this.fixes.get(code)!;
                actions.push(...fixLogic.provideFix(document, diagnostic));
            }
        }
        return actions;
    }
 }
--- a/src/providers/TplCompletionProvider.ts
+++ b/src/providers/TplCompletionProvider.ts
@ -0,0 +1,37 @@
 import * as vscode from 'vscode';
 import { CompletionStrategy } from './completions/CompletionStrategy';
 import { SnippetCompletion } from './completions/SnippetCompletion';
 import { BuiltInCompletion } from './completions/BuiltInCompletion';
 import { LocalContextCompletion } from './completions/LocalContextCompletion';
 export class TplCompletionProvider implements vscode.CompletionItemProvider {
    private strategies: CompletionStrategy[];
    constructor() {
        this.strategies = [
            new BuiltInCompletion(),
            new SnippetCompletion(),
            new LocalContextCompletion()
        ];
    }
    public async provideCompletionItems(
        document: vscode.TextDocument, 
        position: vscode.Position, 
        token: vscode.CancellationToken, 
        context: vscode.CompletionContext
    ): Promise<vscode.CompletionItem[]> {
        const linePrefix = document.lineAt(position).text.substring(0, position.character);
        const results: vscode.CompletionItem[] = [];
        for (const strategy of this.strategies) {
            const items = await strategy.provideCompletions(document, position, linePrefix);
            if (items && items.length > 0) {
                results.push(...items);
            }
        }
        return results;
    }
 }
--- a/src/providers/TplDefinitionProvider.ts
+++ b/src/providers/TplDefinitionProvider.ts
@ -0,0 +1,53 @@
 import * as vscode from 'vscode';
 import { workspaceIndex } from '../core/WorkspaceIndex';
 export class TplDefinitionProvider implements vscode.DefinitionProvider {
    public async provideDefinition(document: vscode.TextDocument, position: vscode.Position, token: vscode.CancellationToken): Promise<vscode.Definition | null> {
        const range = document.getWordRangeAtPosition(position, /[a-zA-Z0-9_.]+/);
        if (!range) {return null;}
        const word = document.getText(range);
        const parts = word.split('.');
        const funcName = parts.length > 1 ? parts[1] : word;
        const text = document.getText();
        // 1. LOKALE SUCHE: Ist die Funktion in der gleichen Datei?
        const lines = text.split('\n');
        for (let i = 0; i < lines.length; i++) {
            const match = lines[i].match(new RegExp(`^\\s*define\\s+${funcName}\\b`));
            if (match) {
                // Wir haben sie lokal gefunden! Springe exakt dorthin.
                return new vscode.Location(document.uri, new vscode.Position(i, lines[i].indexOf(funcName)));
            }
        }
        // 2. GLOBALE SUCHE: Den RAM-Index nach anderen Modulen fragen
        const signatures = workspaceIndex.getFunctionSignatures(funcName);
        if (parts.length > 1) {
            const prefix = parts[0];
            // Wir schauen, ob es über from X import <prefix> importiert wurde
            const importRegex = new RegExp(`from\\s+([a-zA-Z0-9_.]+)\\s+import\\s+[\\s\\S]*?\\b${prefix}\\b`);
            const match = importRegex.exec(text);
            if (match) {
                const moduleName = match[1];
                const targetFunc = signatures.find(sig => sig.moduleName === moduleName && sig.name.endsWith(`.${funcName}`));
                if (targetFunc && targetFunc.fsPath) {
                    const uri = vscode.Uri.file(targetFunc.fsPath);
                    return new vscode.Location(uri, new vscode.Position(targetFunc.lineIdx, 0));
                }
            }
        }
        // 3. FALLBACK: Wenn es nicht als 'prefix.funktion' stand, aber eindeutig im Workspace ist
        if (signatures.length > 0 && signatures[0].fsPath) {
            const uri = vscode.Uri.file(signatures[0].fsPath);
            return new vscode.Location(uri, new vscode.Position(signatures[0].lineIdx, 0));
        }
        // Wenn es eine Built-in Methode ist (wie discovery.runCommand), springt er nirgends hin
        return null; 
    }
 }
--- a/src/providers/TplDocumentFormatter.ts
+++ b/src/providers/TplDocumentFormatter.ts
@ -0,0 +1,50 @@
 import * as vscode from 'vscode';
 import { FormatState } from './formatters/FormatState';
 import { IndentationRules } from './formatters/IndentationRules';
 import { AlignmentRules } from './formatters/AlignmentRules';
 export class TplDocumentFormatter implements vscode.DocumentFormattingEditProvider {
    private indentRules = new IndentationRules();
    private alignRules = new AlignmentRules();
    public provideDocumentFormattingEdits(
        document: vscode.TextDocument, 
        options: vscode.FormattingOptions, 
        token: vscode.CancellationToken
    ): vscode.ProviderResult<vscode.TextEdit[]> {
        const edits: vscode.TextEdit[] = [];
        const state = new FormatState();
        // Nutze die VS Code Settings (meist 4 Spaces), andernfalls Fallback
        state.tabSize = options.tabSize || 4;
        for (let i = 0; i < document.lineCount; i++) {
            const originalLine = document.lineAt(i);
            const rawText = originalLine.text;
            const trimmedText = rawText.trim();
            // Leere Zeilen lassen wir leer
            if (trimmedText.length === 0) {
                if (rawText.length > 0) {
                    // Löscht unnötige Whitespaces in eigentlich leeren Zeilen
                    edits.push(vscode.TextEdit.replace(originalLine.range, ''));
                }
                continue; 
            }
            // 1. Basis-Einrückung (if/else/pattern) berechnen
            let formattedText = this.indentRules.apply(trimmedText, state);
            // 2. Visual Alignment (Klammern) anwenden & Stack updaten
            formattedText = this.alignRules.apply(trimmedText, formattedText, state);
            // 3. Edit nur erstellen, wenn sich die Zeile wirklich ändert (spart Performance & Cursor-Sprünge)
            if (rawText !== formattedText) {
                edits.push(vscode.TextEdit.replace(originalLine.range, formattedText));
            }
        }
        return edits;
    }
 }
--- a/src/providers/TplHoverProvider.ts
+++ b/src/providers/TplHoverProvider.ts
@ -0,0 +1,39 @@
 import * as vscode from 'vscode';
 import { TplLookup } from '../core/TplLookup';
 import { workspaceIndex } from '../core/WorkspaceIndex';
 export class TplHoverProvider implements vscode.HoverProvider {
    public provideHover(document: vscode.TextDocument, position: vscode.Position, token: vscode.CancellationToken): vscode.ProviderResult<vscode.Hover> {
        const range = document.getWordRangeAtPosition(position, /[a-zA-Z0-9_.]+/);
        if (!range) {return null;}
        const word = document.getText(range);
        const parts = word.split('.');
        if (parts.length > 1) {
            // 1. Suche in Core & TKU Built-Ins (Case-Insensitive)
            const funcData = TplLookup.getBuiltInFunction(parts[0], parts[1]);
            if (funcData) {
                const md = new vscode.MarkdownString();
                md.appendCodeblock(`${parts[0]}.${parts[1]}(${funcData.snippets?.[0] || ''})`, 'tpl');
                md.appendMarkdown(`---\n${funcData.description}`);
                return new vscode.Hover(md);
            }
        }
        // 2. Suche in lokalem Workspace (RAM Index)
        const funcName = parts.length > 1 ? parts[1] : word;
        const signatures = workspaceIndex.getFunctionSignatures(funcName);
        if (signatures.length > 0) {
            const sig = signatures[0];
            const md = new vscode.MarkdownString();
            md.appendCodeblock(`define ${sig.name}(${sig.params.join(', ')})`, 'tpl');
            if (sig.docString) {
                md.appendMarkdown(`---\n${sig.docString}`);
            }
            return new vscode.Hover(md);
        }
        return null;
    }
 }
--- a/src/providers/actions/LogFix.ts
+++ b/src/providers/actions/LogFix.ts
@ -0,0 +1,22 @@
 import * as vscode from 'vscode';
 export class LogFix {
    public diagnosticCode = 'missing_log_start';
    public provideFix(document: vscode.TextDocument, diagnostic: vscode.Diagnostic): vscode.CodeAction[] {
        const action = new vscode.CodeAction("Insert missing log statement", vscode.CodeActionKind.QuickFix);
        action.edit = new vscode.WorkspaceEdit();
        const expectedLog = diagnostic.source; 
        if (expectedLog) {
            const insertPos = new vscode.Position(diagnostic.range.start.line + 1, 0);
            // 8 Leerzeichen Einrückung für den Body-Inhalt
            action.edit.insert(document.uri, insertPos, `        ${expectedLog}\n`);
            action.diagnostics = [diagnostic];
            action.isPreferred = true;
            return [action];
        }
        return [];
    }
 }
--- a/src/providers/actions/MetadataFix.ts
+++ b/src/providers/actions/MetadataFix.ts
@ -0,0 +1,32 @@
 import * as vscode from 'vscode';
 import { TplQuickFix } from './TplQuickFix';
 export class MetadataFix implements TplQuickFix {
    public readonly diagnosticCode = 'missing_module_metadata';
    public provideFix(document: vscode.TextDocument, diagnostic: vscode.Diagnostic): vscode.CodeAction[] {
        const fix = new vscode.CodeAction("Fehlende Metadaten generieren", vscode.CodeActionKind.QuickFix);
        fix.edit = new vscode.WorkspaceEdit();
        const config = vscode.workspace.getConfiguration('tpl');
        const author = config.get<string>('metadata.author', 'default');
        const origin = config.get<string>('metadata.origin', 'Custom');
        const publisher = config.get<string>('metadata.publisher', 'IT-Operations');
        const treePathBase = config.get<string>('metadata.treePathBase', 'default');
        const missingFieldsStr = diagnostic.message.replace('Fehlende Pflicht-Metadaten (Modul-Ebene): ', '');
        const missingFields = missingFieldsStr.split(', ');
        let insertText = '';
        if (missingFields.includes('origin')) {insertText += `    origin := '${origin}';\n`;}
        if (missingFields.includes('author')) {insertText += `    author := '${author}';\n`;}
        if (missingFields.includes('products')) {insertText += `    products := 'TODO_Product';\n`;}
        if (missingFields.includes('publishers')) {insertText += `    publishers := '${publisher}';\n`;}
        if (missingFields.includes('tree_path')) {insertText += `    tree_path := '${treePathBase}', 'TODO_Category', 'TODO_Subcategory';\n`;}
        fix.edit.insert(document.uri, new vscode.Position(diagnostic.range.start.line + 1, 0), insertText);
        fix.diagnostics = [diagnostic];
        return [fix];
    }
 }
--- a/src/providers/actions/TabFix.ts
+++ b/src/providers/actions/TabFix.ts
@ -0,0 +1,19 @@
 import * as vscode from 'vscode';
 export class TabFix {
    public diagnosticCode = 'invalid_tab';
    public provideFix(document: vscode.TextDocument, diagnostic: vscode.Diagnostic): vscode.CodeAction[] {
        const action = new vscode.CodeAction("Convert tabs to 4 spaces", vscode.CodeActionKind.QuickFix);
        action.edit = new vscode.WorkspaceEdit();
        const line = document.lineAt(diagnostic.range.start.line);
        const newText = line.text.replace(/\t/g, '    ');
        action.edit.replace(document.uri, line.range, newText);
        action.diagnostics = [diagnostic];
        action.isPreferred = true;
        return [action];
    }
 }
--- a/src/providers/actions/TplQuickFix.ts
+++ b/src/providers/actions/TplQuickFix.ts
@ -0,0 +1,9 @@
 import * as vscode from 'vscode';
 export interface TplQuickFix {
    // Der Fehlercode aus dem Linter (z.B. 'invalid_tab')
    readonly diagnosticCode: string;
    // Die Methode, die den Fix generiert
    provideFix(document: vscode.TextDocument, diagnostic: vscode.Diagnostic): vscode.CodeAction[];
 }
--- a/src/providers/completions/BuiltInCompletion.ts
+++ b/src/providers/completions/BuiltInCompletion.ts
@ -0,0 +1,57 @@
 import * as vscode from 'vscode';
 import { CompletionStrategy } from './CompletionStrategy';
 import { TplLookup } from '../../core/TplLookup';
 export class BuiltInCompletion implements CompletionStrategy {
    public async provideCompletions(document: vscode.TextDocument, position: vscode.Position, linePrefix: string): Promise<vscode.CompletionItem[] | undefined> {
        const dotMatch = linePrefix.match(/\b([a-zA-Z0-9_]+(?:\.[a-zA-Z0-9_]+)*)\.([a-zA-Z0-9_]*)$/);
        if (dotMatch) {
            const prefix = dotMatch[1]; 
            const items: vscode.CompletionItem[] = [];
            let isHandled = false;
            // NEU: Case-Insensitive Lookup (findet Core UND TKU Methoden!)
            const methods = TplLookup.getAllMethodsForNamespace(prefix);
            if (methods) {
                isHandled = true;
                for (const [funcName, funcData] of Object.entries(methods)) {
                    const item = new vscode.CompletionItem(funcName, vscode.CompletionItemKind.Method);
                    item.detail = `TPL Built-in: ${prefix}.${funcName}`;
                    item.documentation = new vscode.MarkdownString(funcData.description);
                    if (funcData.snippets && funcData.snippets.length > 0) {
                        item.insertText = new vscode.SnippetString(`${funcName}(${funcData.snippets[0]});$0`);
                    } else {
                        item.insertText = new vscode.SnippetString(`${funcName}();$0`);
                    }
                    items.push(item);
                }
            }
            // Dynamische Konstruktoren für 'model', 'model.rel' etc. bleiben hier unverändert...
            if (prefix.toLowerCase() === 'model') {
                isHandled = true;
                const dynamicItem = new vscode.CompletionItem('<NodeKind>', vscode.CompletionItemKind.Constructor);
                dynamicItem.detail = "Dynamic Taxonomy Node";
                dynamicItem.documentation = new vscode.MarkdownString("The `model` scope is automatically populated with a function named after each node kind defined in the taxonomy.");
                dynamicItem.insertText = new vscode.SnippetString("${1:NodeKind}(key := ${2:key_value});$0");
                items.push(dynamicItem);
            } 
            else if (prefix.toLowerCase() === 'model.rel' || prefix.toLowerCase() === 'model.uniquerel') {
                isHandled = true;
                const dynamicItem = new vscode.CompletionItem('<Relationship>', vscode.CompletionItemKind.Constructor);
                dynamicItem.detail = prefix.toLowerCase() === 'model.rel' ? "Dynamic Taxonomy Relationship" : "Dynamic Unique Taxonomy Relationship";
                dynamicItem.documentation = new vscode.MarkdownString(`The \`${prefix}\` scope is automatically populated with a function named after each relationship defined in the taxonomy.`);
                dynamicItem.insertText = new vscode.SnippetString("${1:RelationshipName}(${2:SourceRole} := ${3:source_node}, ${4:DestinationRole} := ${5:dest_node});$0");
                items.push(dynamicItem);
            }
            if (isHandled) {
                return items;
            }
        }
        return undefined;
    }
 }
--- a/src/providers/completions/CompletionStrategy.ts
+++ b/src/providers/completions/CompletionStrategy.ts
@ -0,0 +1,9 @@
 import * as vscode from 'vscode';
 export interface CompletionStrategy {
    provideCompletions(
        document: vscode.TextDocument, 
        position: vscode.Position, 
        linePrefix: string
    ): vscode.ProviderResult<vscode.CompletionItem[] | undefined>;
 }
--- a/src/providers/completions/LocalContextCompletion.ts
+++ b/src/providers/completions/LocalContextCompletion.ts
@ -0,0 +1,161 @@
 import * as vscode from 'vscode';
 import { CompletionStrategy } from './CompletionStrategy';
 import { tplBuiltIns } from '../../data/TplBuiltIns';
 import { workspaceIndex } from '../../core/WorkspaceIndex';
 export class LocalContextCompletion implements CompletionStrategy {
    public async provideCompletions(document: vscode.TextDocument, position: vscode.Position, linePrefix: string): Promise<vscode.CompletionItem[] | undefined> {
        const text = document.getText();
        const items: vscode.CompletionItem[] = [];
        const textBeforeCursor = document.getText(new vscode.Range(new vscode.Position(0, 0), position));
        const lastFromIndex = textBeforeCursor.lastIndexOf('from ');
        const lastSemicolonIndex = textBeforeCursor.lastIndexOf(';');
        // 1 & 2. MULTI-LINE SMART IMPORT
        // Wenn das letzte 'from' NACH dem letzten Semikolon kam, sind wir mitten in einem Import-Block!
        if (lastFromIndex > lastSemicolonIndex || (lastFromIndex !== -1 && lastSemicolonIndex === -1)) {
            const importContext = textBeforeCursor.substring(lastFromIndex);
            const match = importContext.match(/^from\s+([a-zA-Z0-9_.]+)\s+import/);
            if (!match) {
                // Wir tippen noch den Modul-Namen
                for (const mod of workspaceIndex.getAllModules()) {
                    const item = new vscode.CompletionItem(mod, vscode.CompletionItemKind.Module);
                    item.detail = "Workspace Module";
                    items.push(item);
                }
                return items;
            } else {
                // Wir tippen die zu importierenden Klassen/Patterns (auch nach Zeilenumbrüchen!)
                const modName = match[1];
                for (const defBlock of workspaceIndex.getDefinitionBlocksForModule(modName)) {
                    const item = new vscode.CompletionItem(defBlock, vscode.CompletionItemKind.Class);
                    item.detail = `Available in ${modName}`;
                    items.push(item);
                }
                return items; // Nichts anderes vorschlagen!
            }
        }
        // 3. NAMESPACE CALLS: "prefix."
        const dotMatch = linePrefix.match(/\b([a-zA-Z0-9_]+)\.([a-zA-Z0-9_]*)$/);
        if (dotMatch) {
            const prefix = dotMatch[1]; 
            // BMC Built-ins ignorieren (übernimmt BuiltInCompletion)
            const bmcNamespaces = Object.keys(tplBuiltIns);
            if (bmcNamespaces.includes(prefix)) {
                return undefined; // Hier darf undefined sein, weil BuiltInCompletion das fängt
            }
            let funcs = [];
            // A) RAM-Abfrage für importierte Module
            const importRegex = new RegExp(`from\\s+([a-zA-Z0-9_.]+)\\s+import\\s+[\\s\\S]*?\\b${prefix}\\b`);
            const match = importRegex.exec(text);
            if (match) {
                const moduleName = match[1];
                // Filtere Funktionen aus dem importierten Modul, die zu diesem Prefix gehören
                funcs = workspaceIndex.getFunctionsForModule(moduleName).filter(f => f.name.startsWith(`${prefix}.`) || !f.name.includes('.'));
            } else {
                // B) Lokale Definitions in der aktuellen Datei prüfen!
                const localDefRegex = new RegExp(`^\\s*definitions?\\s+${prefix}\\b`, 'm');
                if (localDefRegex.test(text)) {
                    const lines = text.split('\n');
                    let inTargetBlock = false;
                    for (const line of lines) {
                        if (line.match(new RegExp(`^\\s*definitions?\\s+${prefix}\\b`))) { inTargetBlock = true; continue; }
                        if (line.match(/^\s*end\s+definitions?/)) { inTargetBlock = false; continue; }
                        if (inTargetBlock) {
                            const defineMatch = line.match(/^\s*define\s+([a-zA-Z0-9_]+)\b(?:\s*\((.*?)\))?/);
                            if (defineMatch) {
                                const params = (defineMatch[2] || "").split(',').map(p => p.trim()).filter(p => p.length > 0);
                                funcs.push({ name: defineMatch[1], moduleName: 'local', params: params });
                            }
                        }
                    }
                }
            }
            if (funcs.length > 0) {
                for (const f of funcs) {
                    const shortName = f.name.split('.').pop() || f.name;
                    const item = new vscode.CompletionItem(shortName, vscode.CompletionItemKind.Function);
                    item.detail = f.moduleName === 'local' ? `Local Method` : `Method from ${f.moduleName}`;
                    // Dynamische Parameter-Generierung! Baut z.B. ${1:host}, ${2:ip}
                    let paramSnippet = "";
                    if (f.params && f.params.length > 0) {
                        paramSnippet = f.params.map((p, idx) => `\${${idx + 1}:${p}}`).join(', ');
                    }
                    item.insertText = new vscode.SnippetString(`${shortName}(${paramSnippet});$0`);
                    items.push(item);
                }
                return items; // Gibt exakt die gefundenen Funktionen zurück
            }
            // Wenn es ein unbekannter Namespace mit Punkt ist, geben wir ein leeres Array [] zurück!
            // Das zwingt VS Code dazu, KEINE generischen Textwörter vorzuschlagen.
            return []; 
        }
        // 4. LOKALE DEFINITIONS PARSEN (Für den globalen Scope, noch ohne Punkt aufgerufen)
        const lines = text.split('\n');
        let currentDefBlock = "";
        for (let i = 0; i < lines.length; i++) {
            const line = lines[i];
            const defBlockMatch = line.match(/^\s*definitions?\s+([a-zA-Z0-9_]+)/);
            if (defBlockMatch) { currentDefBlock = defBlockMatch[1]; continue; }
            if (line.match(/^\s*end\s+definitions?/)) { currentDefBlock = ""; continue; }
            const defineMatch = line.match(/^\s*define\s+([a-zA-Z0-9_]+)\b(?:\s*\((.*?)\))?/);
            if (defineMatch) {
                const funcName = defineMatch[1];
                const fullName = currentDefBlock ? `${currentDefBlock}.${funcName}` : funcName;
                const item = new vscode.CompletionItem(fullName, vscode.CompletionItemKind.Function);
                item.detail = currentDefBlock ? `Local Function in '${currentDefBlock}'` : `Local Function`;
                // Dynamische Parameter-Generierung
                const params = (defineMatch[2] || "").split(',').map(p => p.trim()).filter(p => p.length > 0);
                let paramSnippet = "";
                if (params.length > 0) {
                    paramSnippet = params.map((p, idx) => `\${${idx + 1}:${p}}`).join(', ');
                }
                item.insertText = new vscode.SnippetString(`${fullName}(${paramSnippet});$0`);
                items.push(item);
            }
        }
        // Import-Referenzen für den globalen Scope bereitstellen (angepasst für Multi-Line)
        const fromImportRegex = /from\s+([a-zA-Z0-9_.]+)\s+import\s+([\s\S]*?);/g;
        let matchVar;
        while ((matchVar = fromImportRegex.exec(text)) !== null) {
            const moduleName = matchVar[1];
            const imports = matchVar[2].split(',').map(i => i.trim().split(/\s+/)[0]);
            for (const imp of imports) {
                if (imp.length > 0) {
                    const item = new vscode.CompletionItem(imp, vscode.CompletionItemKind.Module);
                    item.detail = `Imported from ${moduleName}`;
                    items.push(item);
                }
            }
        }
        // Lokale Variablen (:=) vorschlagen
        const varRegex = /([a-zA-Z0-9_]+)\s*:=/g;
        const foundVars = new Set<string>();
        while ((matchVar = varRegex.exec(text)) !== null) {
            if (matchVar[1] !== 'host') { foundVars.add(matchVar[1]); }
        }
        for (const v of foundVars) {
            items.push(new vscode.CompletionItem(v, vscode.CompletionItemKind.Variable));
        }
        return items;
    }
 }
--- a/src/providers/completions/SnippetCompletion.ts
+++ b/src/providers/completions/SnippetCompletion.ts
@ -0,0 +1,120 @@
 import * as vscode from 'vscode';
 import { CompletionStrategy } from './CompletionStrategy';
 export class SnippetCompletion implements CompletionStrategy {
    public async provideCompletions(document: vscode.TextDocument, position: vscode.Position, linePrefix: string): Promise<vscode.CompletionItem[] | undefined> {
        if (linePrefix.match(/\.[a-zA-Z0-9_]*$/)) { return undefined; }
        const items: vscode.CompletionItem[] = [];
        const textBeforeCursor = document.getText(new vscode.Range(new vscode.Position(0, 0), position));
        const inPattern = textBeforeCursor.lastIndexOf('pattern ') > textBeforeCursor.lastIndexOf('end pattern;');
        const inSyncmapping = textBeforeCursor.lastIndexOf('syncmapping ') > textBeforeCursor.lastIndexOf('end syncmapping;');
        const inBlock = inPattern || inSyncmapping;
        const config = vscode.workspace.getConfiguration('tpl');
        const author = config.get<string>('metadata.author', 'Kuro');
        const origin = config.get<string>('metadata.origin', 'Custom');
        const publisher = config.get<string>('metadata.publisher', 'IT-Operations');
        const version = config.get<string>('version', '23');
        // Dynamischer Tree-Path
        const minLevels = config.get<number>('metadata.treePath.minLevels', 3);
        const staticNodes = config.get<string[]>('metadata.treePath.staticNodes', ['Grafing']);
        let treePathStr = '';
        let snippetTabIdx = 1;
        for (let i = 0; i < minLevels; i++) {
            if (i < staticNodes.length) {
                treePathStr += `'${staticNodes[i]}'`;
            } else {
                treePathStr += `'\${${snippetTabIdx}:Level_${i+1}}'`;
                snippetTabIdx++;
            }
            if (i < minLevels - 1) {treePathStr += ', ';}
        }
        // Dynamischer Modul-Metadata-Block
        let metadataBlock = 'metadata\n';
        if (config.get<boolean>('metadata.require.origin', true)) {metadataBlock += `    origin := '${origin}';\n`;}
        if (config.get<boolean>('metadata.require.treePath', true)) {metadataBlock += `    tree_path := ${treePathStr};\n`;}
        if (config.get<boolean>('metadata.require.products', true)) {metadataBlock += `    products := '\${${snippetTabIdx++}:Product}';\n`;}
        if (config.get<boolean>('metadata.require.publishers', true)) {metadataBlock += `    publishers := '${publisher}';\n`;}
        if (config.get<boolean>('metadata.require.author', true)) {metadataBlock += `    author := '${author}';\n`;}
        metadataBlock += 'end metadata;';
        if (!inBlock) {
            const skeleton = new vscode.CompletionItem('tpl_skeleton', vscode.CompletionItemKind.Snippet);
            skeleton.detail = "Generiert ein frisches TPL Modul";
            skeleton.insertText = new vscode.SnippetString(
                `tpl 1.\${${snippetTabIdx++}:${version}} module \${${snippetTabIdx++}:MyModule};\n\n` +
                `${metadataBlock}\n\n` +
                `pattern \${${snippetTabIdx++}:MyPattern} 1.0\n` +
                `    """\n    \${${snippetTabIdx++}:Beschreibung des Patterns}\n    """\n` +
                `    metadata\n` +
                `        publishers := '${publisher}';\n` +
                `        tags := '\${${snippetTabIdx++}:Tags}';\n` +
                `    end metadata;\n\n` +
                `    overview\n` +
                `        tags \${${snippetTabIdx++}:Tags};\n` +
                `    end overview;\n\n` +
                `    constants\n` +
                `        \${${snippetTabIdx++}:const_name} := '\${${snippetTabIdx++}:value}';\n` +
                `    end constants;\n\n` +
                `    triggers\n` +
                `        on process := SoftwareInstance created, confirmed where type = '\${${snippetTabIdx++}:Type}';\n` +
                `    end triggers;\n\n` +
                `    body\n` +
                `        log.debug("Start pattern %pattern_name%");\n` +
                `        $0\n` +
                `    end body;\n` +
                `end pattern;`
            );
            items.push(skeleton);
            const modMeta = new vscode.CompletionItem('metadata', vscode.CompletionItemKind.Snippet);
            modMeta.detail = "Modul-Metadaten Block (Pflichtfelder)";
            modMeta.insertText = new vscode.SnippetString(`${metadataBlock}\n$0`);
            items.push(modMeta);
        }
        if (inBlock) {
            const patMeta = new vscode.CompletionItem('metadata', vscode.CompletionItemKind.Snippet);
            patMeta.detail = "Pattern-Metadaten Block";
            patMeta.insertText = new vscode.SnippetString(
                `metadata\n` +
                `    publishers := '${publisher}';\n` +
                `    tags := '\${1:Tags}';\n` +
                `end metadata;\n$0`
            );
            items.push(patMeta);
        }
        const ifSnippet = new vscode.CompletionItem('if', vscode.CompletionItemKind.Snippet);
        ifSnippet.insertText = new vscode.SnippetString(`if \${1:condition} then\n    $0\nend if;`);
        items.push(ifSnippet);
        const elifSnippet = new vscode.CompletionItem('elif', vscode.CompletionItemKind.Snippet);
        elifSnippet.insertText = new vscode.SnippetString(`elif \${1:condition} then\n    $0`);
        items.push(elifSnippet);
        const elseSnippet = new vscode.CompletionItem('else', vscode.CompletionItemKind.Snippet);
        elseSnippet.insertText = new vscode.SnippetString(`else\n    $0`);
        items.push(elseSnippet);
        const forSnippet = new vscode.CompletionItem('for', vscode.CompletionItemKind.Snippet);
        forSnippet.insertText = new vscode.SnippetString(`for \${1:item} in \${2:list} do\n    $0\nend for;`);
        items.push(forSnippet);
        const whileSnippet = new vscode.CompletionItem('while', vscode.CompletionItemKind.Snippet);
        whileSnippet.insertText = new vscode.SnippetString(`while \${1:condition} do\n    $0\nend while;`);
        items.push(whileSnippet);
        const defineSnippet = new vscode.CompletionItem('define', vscode.CompletionItemKind.Snippet);
        defineSnippet.insertText = new vscode.SnippetString(`define \${1:name}(\${2:params})\n    """\n    \${3:DocString}\n    """\n    $0\nend define;`);
        items.push(defineSnippet);
        return items;
    }
 }
--- a/src/providers/formatters/AlignmentRules.ts
+++ b/src/providers/formatters/AlignmentRules.ts
@ -0,0 +1,41 @@
 import { FormatState } from './FormatState';
 export class AlignmentRules {
    public apply(line: string, formattedLine: string, state: FormatState): string {
        let finalLine = formattedLine;
        // Wenn wir innerhalb einer offenen Klammer sind, überschreibe die Block-Einrückung
        if (state.parenAlignments.length > 0) {
            const alignCol = state.parenAlignments[state.parenAlignments.length - 1];
            finalLine = ' '.repeat(alignCol) + line;
        } else if (state.bracketAlignments.length > 0) {
            const alignCol = state.bracketAlignments[state.bracketAlignments.length - 1];
            finalLine = ' '.repeat(alignCol) + line;
        }
        // Aktualisiere Stacks basierend auf der FINAL formatierten Zeile (wichtig für die Spaltenzahl!)
        this.updateAlignments(finalLine, state);
        return finalLine;
    }
    private updateAlignments(line: string, state: FormatState) {
        // Strings ignorieren, damit wir keine Klammern in Log-Texten zählen
        let cleanLine = line.replace(/"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'/g, '""');
        for (let i = 0; i < cleanLine.length; i++) {
            const char = cleanLine[i];
            if (char === '(') {
                // Einrückung ab dem Zeichen NACH der offenen Klammer
                state.parenAlignments.push(i + 1); 
            } else if (char === ')') {
                state.parenAlignments.pop();
            } else if (char === '[') {
                state.bracketAlignments.push(i + 1);
            } else if (char === ']') {
                state.bracketAlignments.pop();
            }
        }
    }
 }
--- a/src/providers/formatters/FormatState.ts
+++ b/src/providers/formatters/FormatState.ts
@ -0,0 +1,15 @@
 export class FormatState {
    public indentLevel: number = 0;
    public tabSize: number = 4;
    // Speichert die Spalten-Position offener Klammern für Visual Alignment
    public parenAlignments: number[] = [];
    public bracketAlignments: number[] = [];
    public inImportBlock: boolean = false;
    // Gibt die aktuellen Basis-Leerzeichen zurück (z.B. Level 2 = 8 Leerzeichen)
    public get currentIndentString(): string {
        return ' '.repeat(this.indentLevel * this.tabSize);
    }
 }
--- a/src/providers/formatters/IndentationRules.ts
+++ b/src/providers/formatters/IndentationRules.ts
@ -0,0 +1,79 @@
 import { FormatState } from './FormatState';
 export class IndentationRules {
    public apply(line: string, state: FormatState): string {
        if (line.trim().length === 0) {return "";}
        let cleanLine = "";
        let inString = false;
        let stringChar = '';
        let inTripleQuote = false;
        for (let i = 0; i < line.length; i++) {
            const char = line[i];
            if (!inString && !inTripleQuote && char === '/' && line[i+1] === '/') {break;}
            if (!inString && !inTripleQuote && (char === '"' || char === "'") && line[i+1] === char && line[i+2] === char) {
                inTripleQuote = true; stringChar = char; cleanLine += char+char+char; i += 2; continue;
            }
            if (inTripleQuote) {
                if (char === stringChar && line[i+1] === stringChar && line[i+2] === stringChar) {
                    inTripleQuote = false; cleanLine += char+char+char; i += 2;
                }
                continue; 
            }
            if (inString) {
                if (char === '\\') {i++;} else if (char === stringChar) {inString = false;}
                continue; 
            }
            if (!inString && !inTripleQuote && (char === '"' || char === "'")) {
                inString = true; stringChar = char; cleanLine += char; continue;
            }
            cleanLine += char;
        }
        cleanLine = cleanLine.trim();
        const trimmedLine = line.trimStart();
        // 3. DEDENT
        if (/^end\b/.test(cleanLine)) {
            state.indentLevel = Math.max(0, state.indentLevel - 1);
        } else if (/^(elif|else)\b/.test(cleanLine)) {
            state.indentLevel = Math.max(0, state.indentLevel - 1);
        }
        // 4. SET SPACES
        let result = trimmedLine;
        if (state.parenAlignments && state.parenAlignments.length > 0) {
            // Visual Alignment greift später
        } else if (state.inImportBlock) {
            if (!cleanLine.startsWith('from ')) {
                result = " ".repeat((state.indentLevel + 2) * state.tabSize) + trimmedLine;
            } else {
                result = state.currentIndentString + trimmedLine;
            }
        } else {
            result = state.currentIndentString + trimmedLine;
        }
        // 5. INDENT (Gefixt: Mutually Exclusive / else if)
        if (/^(pattern|syncmapping|table|definitions?|define|enumeration|configuration|overview|metadata|constants|triggers|body|mapping|removal)\b/.test(cleanLine)) {
            state.indentLevel++;
        } else if (/\b(then|do)\b$/.test(cleanLine)) {
            state.indentLevel++;
        } else if (/^else\b/.test(cleanLine)) {
            state.indentLevel++;
        }
        // 6. Import Block Tracking
        if (cleanLine.startsWith('from ')) {
            state.inImportBlock = true;
        }
        if (state.inImportBlock && cleanLine.endsWith(';')) {
            state.inImportBlock = false;
        }
        return result;
    }
 }
--- a/src/test/extension.test.ts
+++ b/src/test/extension.test.ts
@ -1,15 +0,0 @@
 import * as assert from 'assert';
 // You can import and use all API from the 'vscode' module
 // as well as import your extension to test it
 import * as vscode from 'vscode';
 // import * as myExtension from '../../extension';
 suite('Extension Test Suite', () => {
 	vscode.window.showInformationMessage('Start all tests.');
 	test('Sample test', () => {
 		assert.strictEqual(-1, [1, 2, 3].indexOf(5));
 		assert.strictEqual(-1, [1, 2, 3].indexOf(0));
 	});
 });
--- a/src/test/fixtures/format_bad.tpl
+++ b/src/test/fixtures/format_bad.tpl
@ -0,0 +1,9 @@
 tpl 1.21 module TestFormat;
 define format_me()
      // 6 Leerzeichen hier!
  log.debug("2 Leerzeichen hier");
    if true then
   log.debug("3 Leerzeichen!");
    end if;
 end define;
--- a/src/test/fixtures/lexer_edge_cases.tpl
+++ b/src/test/fixtures/lexer_edge_cases.tpl
@ -0,0 +1,14 @@
 tpl 1.21 module TestEdgeCases;
 define my_edge_func()
    """
    Ein böser DocString mit ( [ = und if und end
    """
    // Ein Kommentar mit DiscoveryFunctions.escapePath(1,2,3,4,5,6)
    clean_path := DiscoveryFunctions.escapePath(host, "böse(Klammern)", true);
    if test = "ein_string_mit_komma," then
        log.debug("alles gut");
    end if;
 end define;
--- a/src/test/fixtures/linter_negative.tpl
+++ b/src/test/fixtures/linter_negative.tpl
@ -0,0 +1,12 @@
 tpl 1.21 module TestNegative;
 define my_bad_func()
    // Unbekannte Funktion (Info)
    rdbms_functions.does_not_exist(host);
    // Falsche Parameter-Anzahl (Warning)
    DiscoveryFunctions.escapePath(host, "path", true, "zu_viel");
    // Zuweisung fehlt für Return-Value (Warning)
    DiscoveryFunctions.escapePath(host, "path", true);
 end define;
--- a/src/test/suite/.linter.test.ts.swp
+++ b/src/test/suite/.linter.test.ts.swp
--- a/src/test/suite/actions.test.ts
+++ b/src/test/suite/actions.test.ts
@ -0,0 +1,38 @@
 import * as assert from 'assert';
 import * as vscode from 'vscode';
 import { TabFix } from '../../providers/actions/TabFix';
 import { LogFix } from '../../providers/actions/LogFix';
 suite('Code Actions Test Suite', () => {
    test('TabFix: Generates Replace-Edit for tabs', () => {
        const fix = new TabFix();
        const diag = new vscode.Diagnostic(new vscode.Range(0, 0, 0, 1), "Tab found", vscode.DiagnosticSeverity.Warning);
        // Mock for TextDocument
        const mockDoc = {
            uri: vscode.Uri.file('test.tpl'),
            lineAt: () => ({ text: '\t\tcode', range: new vscode.Range(0, 0, 0, 6) })
        } as any;
        const actions = fix.provideFix(mockDoc, diag);
        assert.strictEqual(actions.length, 1);
        // Update this string if your actual TabFix title differs!
        assert.strictEqual(actions[0].title, "Convert tabs to 4 spaces");
        assert.ok(actions[0].edit !== undefined);
    });
    test('LogFix: Generates Insert-Edit with log statement', () => {
        const fix = new LogFix();
        const diag = new vscode.Diagnostic(new vscode.Range(10, 0, 10, 4), "Missing log");
        diag.source = 'log.debug("Start pattern Test");'; // Linter-Source Simulation
        const mockDoc = { uri: vscode.Uri.file('test.tpl') } as any;
        const actions = fix.provideFix(mockDoc, diag);
        assert.strictEqual(actions.length, 1);
        // Update this string if your actual LogFix title differs!
        assert.strictEqual(actions[0].title, "Insert missing log statement");
    });
 });
--- a/src/test/suite/completions.test.ts
+++ b/src/test/suite/completions.test.ts
@ -0,0 +1,80 @@
 import * as assert from 'assert';
 import * as vscode from 'vscode';
 import { SnippetCompletion } from '../../providers/completions/SnippetCompletion';
 import { LocalContextCompletion } from '../../providers/completions/LocalContextCompletion';
 import { workspaceIndex } from '../../core/WorkspaceIndex';
 function createMockDoc(text: string): any {
    const lines = text.split('\n');
    return {
        getText: () => text,
        lineAt: (i: number) => ({ text: lines[i] })
    };
 }
 suite('Completion Provider Test Suite', () => {
    // Feeds the RAM index with a dummy file before tests
    suiteSetup(() => {
        const dummyUri = vscode.Uri.file('/fake/path/Company.tools.tpl');
        const dummyText = `
 tpl 1.23 module Company.tools;
 definitions network_helpers
    define ping(host, ip)
    end define;
 end definitions;
        `.trim();
        workspaceIndex.updateFile(dummyUri, dummyText);
    });
    test('LocalContextCompletion: "from " suggests only RAM modules', async () => {
        const strategy = new LocalContextCompletion();
        const mockDoc = createMockDoc(`from `);
        const position = new vscode.Position(0, 5);
        const result = await strategy.provideCompletions(mockDoc, position, 'from ');
        assert.ok(result !== undefined);
        const hasModule = result!.some(item => item.label === 'Company.tools');
        assert.strictEqual(hasModule, true, "Must suggest the module from RAM.");
    });
    test('LocalContextCompletion: "from X import " suggests definition blocks', async () => {
        const strategy = new LocalContextCompletion();
        const mockDoc = createMockDoc(`from Company.tools import `);
        const position = new vscode.Position(0, 26);
        const result = await strategy.provideCompletions(mockDoc, position, 'from Company.tools import ');
        assert.ok(result !== undefined);
        const hasBlock = result!.some(item => item.label === 'network_helpers');
        assert.strictEqual(hasBlock, true, "Must suggest the definition block from the module.");
    });
    test('LocalContextCompletion: Blocks fallback for unknown namespace', async () => {
        const strategy = new LocalContextCompletion();
        const mockDoc = createMockDoc(`randomstuff.`);
        const position = new vscode.Position(0, 12);
        const result = await strategy.provideCompletions(mockDoc, position, 'randomstuff.');
        assert.ok(result !== undefined);
        assert.strictEqual(result!.length, 0, "Must return an empty array to block VS Code text spam.");
    });
 test('LocalContextCompletion: Imported namespace generates parameter snippet', async () => {
        const strategy = new LocalContextCompletion();
        const docText = `from Company.tools import network_helpers;\nnetwork_helpers.`;
        const mockDoc = createMockDoc(docText);
        const position = new vscode.Position(1, 16);
        const result = await strategy.provideCompletions(mockDoc, position, 'network_helpers.');
        assert.ok(result !== undefined);
        const funcItem = result!.find(item => item.label === 'ping');
        assert.ok(funcItem !== undefined, "Must find the ping function");
        const snippet = funcItem?.insertText as vscode.SnippetString;
        assert.strictEqual(snippet.value, 'ping(${1:host}, ${2:ip});$0', "Must map parameters exactly");
    });
 });
--- a/src/test/suite/extension.test.ts
+++ b/src/test/suite/extension.test.ts
@ -0,0 +1,112 @@
 import * as assert from 'assert';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as vscode from 'vscode';
 import { ParameterRule } from '../../core/rules/ParameterRule';
 import { IndentationRules } from '../../providers/formatters/IndentationRules';
 import { FormatState } from '../../providers/formatters/FormatState';
 import { LinterContext } from '../../core/LinterContext';
 import { TplLookup } from '../../core/TplLookup';
 import { workspaceIndex } from '../../core/WorkspaceIndex';
 class MockLinterContext extends LinterContext {
    public diagnostics: vscode.Diagnostic[] = [];
    constructor() {
        super();
    }
    public addDiag(lineIdx: number, start: number, end: number, msg: string, severity: vscode.DiagnosticSeverity): vscode.Diagnostic {
        const range = new vscode.Range(lineIdx, start, lineIdx, end);
        const diag = new vscode.Diagnostic(range, msg, severity);
        this.diagnostics.push(diag);
        return diag; 
    }
 }
 suite('BMC TPL Core Engine Tests', () => {
    const fixturesPath = path.resolve(__dirname, '../../../src/test/fixtures');
    suite('TplLookup & Autocomplete', () => {
        test('Should resolve Core and TKU built-ins case-insensitively', () => {
            const runCmd = TplLookup.getBuiltInFunction('discovery', 'runcommand');
            assert.ok(runCmd, 'discovery.runCommand should be found ignoring case');
            const tkuCmd = TplLookup.getBuiltInFunction('COMMON_FUNCTIONS', 'identify_host');
            assert.ok(tkuCmd, 'Common_Functions.identify_host should be found ignoring case');
        });
    });
    suite('ParameterRule (Lexer & Linter)', () => {
        test('Should catch negative cases (unknown func, param count, unused return)', () => {
            const rule = new ParameterRule();
            const ctx = new MockLinterContext();
            const originalGetSignatures = workspaceIndex.getFunctionSignatures.bind(workspaceIndex);
            workspaceIndex.getFunctionSignatures = (name: string) => {
                if (name === 'my_local_func') {
                    return [{
                        name: 'my_local_func',
                        params: ['a', 'b'],
                        hasReturnValue: true,
                        docString: '',
                        moduleName: 'TestNegative',
                        lineIdx: 1,
                        fsPath: 'test.tpl'
                    }];
                }
                return originalGetSignatures(name);
            };
            // GEFIXT: "dummy :=" hinzugefügt, um den doppelten Return-Value-Fehler zu vermeiden
            const content = `tpl 1.21 module TestNegative;
            define test_func()
                unknown_module.does_not_exist(host);
                dummy := my_local_func(1, 2, 3);
                my_local_func(1, 2);
            end define;`;
            const lines = content.split('\n');
            lines.forEach((line, idx) => rule.checkLine(line, line, idx, ctx, lines));
            workspaceIndex.getFunctionSignatures = originalGetSignatures;
            assert.strictEqual(ctx.diagnostics.length, 3, 'Should find exactly 3 errors in negative fixture');
            assert.ok(ctx.diagnostics.some(d => d.message.includes("Unknown function 'unknown_module.does_not_exist'")));
            assert.ok(ctx.diagnostics.some(d => d.message.includes("expects 2 parameter(s), but 3 were provided")));
            assert.ok(ctx.diagnostics.some(d => d.message.includes("is not used. Did you forget an assignment (:=)?")));
        });
        test('Should ignore strings, docstrings and comments (Lexer Edge Cases)', () => {
            const rule = new ParameterRule();
            const ctx = new MockLinterContext();
            const content = fs.readFileSync(path.join(fixturesPath, 'lexer_edge_cases.tpl'), 'utf-8');
            const lines = content.split('\n');
            lines.forEach((line, idx) => rule.checkLine(line, line, idx, ctx, lines));
            assert.strictEqual(ctx.diagnostics.length, 0, 'Should find NO errors in lexer edge cases');
        });
    });
    suite('IndentationRules (Auto-Formatter)', () => {
        test('Should forcefully fix bad indentation', () => {
            const rule = new IndentationRules();
            const state = new FormatState();
            const content = fs.readFileSync(path.join(fixturesPath, 'format_bad.tpl'), 'utf-8');
            const lines = content.split('\n');
            const formattedLines = lines.map(line => rule.apply(line, state));
            assert.strictEqual(formattedLines[3], '    // 6 Leerzeichen hier!');
            assert.strictEqual(formattedLines[4], '    log.debug("2 Leerzeichen hier");');
            assert.strictEqual(formattedLines[5], '    if true then');
            assert.strictEqual(formattedLines[6], '        log.debug("3 Leerzeichen!");');
            assert.strictEqual(formattedLines[7], '    end if;');
        });
    });
 });
--- a/src/test/suite/formatters.test.ts
+++ b/src/test/suite/formatters.test.ts
@ -0,0 +1,53 @@
 import * as assert from 'assert';
 import { FormatState } from '../../providers/formatters/FormatState';
 import { IndentationRules } from '../../providers/formatters/IndentationRules';
 import { AlignmentRules } from '../../providers/formatters/AlignmentRules';
 suite('Formatter Test Suite', () => {
    test('IndentationRules: Indents if/then/end block correctly', () => {
        const indentRules = new IndentationRules();
        const state = new FormatState();
        state.tabSize = 4;
        // Line 1: if condition then (expected: 0 spaces, but level jumps to 1 for the next line)
        let result = indentRules.apply('if x = 1 then', state);
        assert.strictEqual(result, 'if x = 1 then');
        assert.strictEqual(state.indentLevel, 1);
        // Line 2: normal code in block (expected: 4 spaces)
        result = indentRules.apply('log.debug("test");', state);
        assert.strictEqual(result, '    log.debug("test");');
        assert.strictEqual(state.indentLevel, 1);
        // Line 3: end if; (expected: 0 spaces, level jumps to 0 right before output)
        result = indentRules.apply('end if;', state);
        assert.strictEqual(result, 'end if;');
        assert.strictEqual(state.indentLevel, 0);
    });
    test('IndentationRules: elif and else behave correctly', () => {
        const indentRules = new IndentationRules();
        const state = new FormatState();
        state.tabSize = 4;
        state.indentLevel = 1; // We start practically IN an open if-block
        // elif must jump back (to 0) and then back to 1 for the following block
        let result = indentRules.apply('elif x = 2 then', state);
        assert.strictEqual(result, 'elif x = 2 then');
        assert.strictEqual(state.indentLevel, 1);
    });
    test('AlignmentRules: Visual alignment at parentheses', () => {
        const alignRules = new AlignmentRules();
        const state = new FormatState();
        // 1. Line with opening parenthesis
        alignRules.apply('discovery.runCommand(', 'discovery.runCommand(', state);
        assert.strictEqual(state.parenAlignments.length, 1);
        assert.strictEqual(state.parenAlignments[0], 21); // 21 characters until after the open parenthesis
        // 2. Line (parameter should be indented exactly to column 21)
        const result = alignRules.apply('host,', 'host,', state);
        assert.strictEqual(result, '                     host,');
    });
 });
--- a/src/test/suite/linter.test.ts
+++ b/src/test/suite/linter.test.ts
@ -0,0 +1,84 @@
 import * as assert from 'assert';
 import * as vscode from 'vscode';
 import { LinterContext } from '../../core/LinterContext';
 import { SyntaxRule } from '../../core/rules/SyntaxRule';
 import { BlockRule } from '../../core/rules/BlockRule';
 import { validateTplDocument } from '../../core/TplLinter';
 suite('Linter Test Suite', () => {
    test('SyntaxRule: Ignores URLs and special characters in strings', () => {
        const rule = new SyntaxRule();
        const ctx = new LinterContext();
        ctx.activePhaseName = 'body'; // Allowed zone
        const rawLine = '    log.debug("https://example.com/api?q=1//test");';
        rule.checkLine(rawLine.trim(), rawLine, 0, ctx, [rawLine]);
        // Must not throw an error (neither missing semicolon nor broken comment)
        assert.strictEqual(ctx.diagnostics.length, 0);
    });
    test('Linter: Captures TODOs as Information', () => {
        const mockDoc = {
            languageId: 'tpl',
            getText: () => "tpl 1.0 module Test;\n// TODO: refactor this",
            uri: vscode.Uri.file('test.tpl')
        } as any;
        const collection = vscode.languages.createDiagnosticCollection('test-collection');
        validateTplDocument(mockDoc, collection);
        const diags = collection.get(mockDoc.uri);
        assert.strictEqual(diags?.length, 1, "Must find exactly one TODO");
        assert.ok(diags![0].message.includes('TODO: refactor this'));
        assert.strictEqual(diags![0].severity, vscode.DiagnosticSeverity.Information);
    });
    test('SyntaxRule: Multi-line if-condition without semicolon error', () => {
        const rule = new SyntaxRule();
        const ctx = new LinterContext();
        ctx.activePhaseName = 'body';
        // Line 1: or-break
        rule.checkLine('if x = 1 or', 'if x = 1 or', 0, ctx, []);
        assert.strictEqual(ctx.diagnostics.length, 0);
        assert.strictEqual(ctx.inConditionBlock, true);
        // Line 2: then-closure
        rule.checkLine('y = 2 then', 'y = 2 then', 1, ctx, []);
        assert.strictEqual(ctx.diagnostics.length, 0, "'then' must not require a semicolon at the end!");
        assert.strictEqual(ctx.inConditionBlock, false);
    });
    test('SyntaxRule: Allowed allocations in Zones (e.g. metadata)', () => {
        const rule = new SyntaxRule();
        const ctx = new LinterContext();
        ctx.inModuleMetadata = true; // We are in module metadata
        const rawLine = "    origin := 'Custom';";
        rule.checkLine(rawLine.trim(), rawLine, 0, ctx, [rawLine]);
        assert.strictEqual(ctx.diagnostics.length, 0, "Allocations have to be allowed in metadata");
    });
    test('BlockRule: if/for/while stack tracking', () => {
        const mockDoc = {
            languageId: 'tpl',
            getText: () => "tpl 1.0 module Test;\nif condition then\nend for;",
            uri: vscode.Uri.file('test.tpl')
        } as any;
        const collection = vscode.languages.createDiagnosticCollection('test-collection-blockrule');
        validateTplDocument(mockDoc, collection);
        const diags = collection.get(mockDoc.uri);
        // We check language-agnostically: Is there an Error exactly on line 2 (the 'end for;')?
        const hasErrorOnEndFor = diags?.some(d =>
            d.range.start.line === 2 &&
            d.severity === vscode.DiagnosticSeverity.Error
        );
        assert.strictEqual(hasErrorOnEndFor, true, "Need to throw an error on 'end for;' line");
    });
 });
--- a/syntaxes/tpl.tmLanguage.json
+++ b/syntaxes/tpl.tmLanguage.json
--- a/tsconfig.json
+++ b/tsconfig.json
@ -10,6 +10,7 @@
            "mocha"
        ],
        "sourceMap": true,
        "outDir": "out",
        "rootDir": "src",
        "strict": true, /* enable all strict type-checking options */
        /* Additional Checks */
--- a/vsc-extension-quickstart.md
+++ b/vsc-extension-quickstart.md
@ -1,48 +0,0 @@
 # Welcome to your VS Code Extension
 ## What's in the folder
 * This folder contains all of the files necessary for your extension.
 * `package.json` - this is the manifest file in which you declare your extension and command.
  * The sample plugin registers a command and defines its title and command name. With this information VS Code can show the command in the command palette. It doesn’t yet need to load the plugin.
 * `src/extension.ts` - this is the main file where you will provide the implementation of your command.
  * The file exports one function, `activate`, which is called the very first time your extension is activated (in this case by executing the command). Inside the `activate` function we call `registerCommand`.
  * We pass the function containing the implementation of the command as the second parameter to `registerCommand`.
 ## Setup
 * install the recommended extensions (amodio.tsl-problem-matcher, ms-vscode.extension-test-runner, and dbaeumer.vscode-eslint)
 ## Get up and running straight away
 * Press `F5` to open a new window with your extension loaded.
 * Run your command from the command palette by pressing (`Ctrl+Shift+P` or `Cmd+Shift+P` on Mac) and typing `Hello World`.
 * Set breakpoints in your code inside `src/extension.ts` to debug your extension.
 * Find output from your extension in the debug console.
 ## Make changes
 * You can relaunch the extension from the debug toolbar after changing code in `src/extension.ts`.
 * You can also reload (`Ctrl+R` or `Cmd+R` on Mac) the VS Code window with your extension to load your changes.
 ## Explore the API
 * You can open the full set of our API when you open the file `node_modules/@types/vscode/index.d.ts`.
 ## Run tests
 * Install the [Extension Test Runner](https://marketplace.visualstudio.com/items?itemName=ms-vscode.extension-test-runner)
 * Run the "watch" task via the **Tasks: Run Task** command. Make sure this is running, or tests might not be discovered.
 * Open the Testing view from the activity bar and click the Run Test" button, or use the hotkey `Ctrl/Cmd + ; A`
 * See the output of the test result in the Test Results view.
 * Make changes to `src/test/extension.test.ts` or create new test files inside the `test` folder.
  * The provided test runner will only consider files matching the name pattern `**.test.ts`.
  * You can create folders inside the `test` folder to structure your tests any way you want.
 ## Go further
 * Reduce the extension size and improve the startup time by [bundling your extension](https://code.visualstudio.com/api/working-with-extensions/bundling-extension).
 * [Publish your extension](https://code.visualstudio.com/api/working-with-extensions/publishing-extension) on the VS Code extension marketplace.
 * Automate builds by setting up [Continuous Integration](https://code.visualstudio.com/api/working-with-extensions/continuous-integration).
Author	SHA1	Message	Date
kuro	939d9073e6	Merge branch 'master' of https://wiccafe.de/kuro/bmc-tpl-code-all-around	2026-10-28 23:04:53 +01:00
kuro	4f5b7fe1f0	test changes and added nightly build for gitea	2026-10-28 23:04:50 +01:00
kuro	21e6833cb1	Readme update	2026-10-28 21:12:22 +00:00
kuro	a63c490276	Readme update	2026-10-28 21:10:39 +00:00
kuro	3b597e6df4	Fixes for common mistakes the current add on had	2026-10-28 22:04:56 +01:00
kuro	1c160c3e1b	multi line column support, smarter import "from", test changes	2026-10-28 00:14:29 +01:00
kuro	f3506cc10b	added test cases, translated some stuff, fixed intendention rule and parameter adaptation from settings	2026-10-27 23:38:30 +01:00
kuro	43bb2fa250	TKU und EDP Description and Autocomplete added	2026-10-27 17:48:03 +01:00
kuro	0063862a24	started translating every info into english, started adding some functionality for better workspace awareness	2026-10-18 04:38:07 +02:00
kuro	d6e97bea98	readme update	2026-10-18 03:35:39 +02:00
kuro	387f3793df	linter fixes, fixes after refactoring and error fixing after i made MetadataRule seperate from BlockRule	2026-10-18 03:27:52 +02:00
kuro	9dcbf58f3a	refactoring fixes	2026-10-18 03:14:13 +02:00
kuro	13b873cf8f	typing error fix	2026-10-18 03:11:57 +02:00
kuro	00bdc8744d	Merge branch 'master' of https://wiccafe.de/kuro/bmc-tpl-code-all-around	2026-10-18 03:07:29 +02:00
kuro	b9035feb99	Refactoring fixes, translations, extensions for settings	2026-10-18 03:03:33 +02:00
kuro	9299eb6387	Readme nochmal geupdated, wie sie sein sollte	2026-10-15 20:08:38 +00:00
kuro	bda2c0a069	README.md geupdated, hat nun auch englische übersetzung	2026-10-15 20:02:59 +00:00
kuro	1910b0def2	test erweiterungen	2026-10-12 22:23:29 +02:00
kuro	ba836ee30f	erkennung für fehlende end blocks, mehrzeilige if/for/while usw erkennung um keine semikolon fehler zu melden, besseres auslesen import defines, infos werden jetzt auch im Problems fenster gezeigt, bessere autovervollständigung, automatische fehlersuche über das projekt	2026-10-12 21:43:46 +02:00
kuro	eba674218e	Refactoring 3 - providers und formatters weiter unterteilt und angepasst und erste unit tests eingetragen	2026-10-11 06:11:11 +02:00
kuro	132cfacb70	Refactoring teil 2 - TplCodeActionProvider aufgeteilt	2026-10-11 04:36:23 +02:00
kuro	07eb9f7366	Refactoring, alles in neue ordner verschoben und begonnen neu zu unterteilen. dabei wird an der logik erstmal nichts geändert	2026-10-11 04:31:12 +02:00
kuro	eeed4e684b	Einstellungen eingefügt, bei funktionen mit bedingungen autovervollständigung eingefügt, readme angepasst	2026-10-09 23:53:19 +02:00
kuro	f9f44e0312	Autocomplete erweitert mit standard Funktionen von BMC, Hover geht wieder, autogenerierung von sektionen, erweiterung der autovervollständigung um parameter	2026-10-09 23:14:30 +02:00
kuro	a5cd6a74ca	Erweiterung die feste log regel fällt raus, dafür sind jetzt alle möglichen BMC TPL erweiterungen als auto complete drin	2026-10-09 00:36:29 +02:00
kuro	93f3179bcd	git ignore erweitert, unnötige dateien gelöscht, package.json angepasst und license file namen angepasst	2026-10-08 23:15:20 +02:00
kuro	684d760f4b	Komplettes update für die funktionen und beschreibungen	2026-10-08 22:02:08 +02:00