From 3e4ca283c90eae2cdcca10648dac7146c94fc168 Mon Sep 17 00:00:00 2001 From: Michael Schimmel Date: Wed, 3 Sep 2025 09:47:16 +0200 Subject: [PATCH] Ast Refactoring --- ASTPlayground/ASTPlayground.dpr | 3 +- ASTPlayground/ASTPlayground.dproj | 1 - ASTPlayground/MainForm.pas | 4 +- Doc/Visueller AST-Editor.md | 70 +++++++++++++++++++ Doc/Visuelles System für Handelsstrategien.md | 68 ++++++++++++++++++ Src/AST/Myc.Ast.Evaluator.pas | 4 +- Src/AST/Myc.Ast.Nodes.pas | 2 +- Src/AST/Myc.Ast.Printer.pas | 2 +- Src/AST/Myc.Ast.pas | 2 +- .../Data/Myc.Data.Scalar.JSON.pas | 5 +- .../{Myc.Data.POD.pas => Myc.Data.Scalar.pas} | 4 +- 11 files changed, 150 insertions(+), 15 deletions(-) create mode 100644 Doc/Visueller AST-Editor.md create mode 100644 Doc/Visuelles System für Handelsstrategien.md rename ASTPlayground/Myc.Ast.RttiUtils.pas => Src/Data/Myc.Data.Scalar.JSON.pas (95%) rename Src/Data/{Myc.Data.POD.pas => Myc.Data.Scalar.pas} (96%) diff --git a/ASTPlayground/ASTPlayground.dpr b/ASTPlayground/ASTPlayground.dpr index 220bab0..311c3c9 100644 --- a/ASTPlayground/ASTPlayground.dpr +++ b/ASTPlayground/ASTPlayground.dpr @@ -9,8 +9,7 @@ uses Myc.Ast.Nodes in '..\Src\AST\Myc.Ast.Nodes.pas', Myc.Ast.Scope in '..\Src\AST\Myc.Ast.Scope.pas', DraggablePanel in 'DraggablePanel.pas', - Myc.Ast.Visualizer in 'Myc.Ast.Visualizer.pas', - Myc.Ast.RttiUtils in 'Myc.Ast.RttiUtils.pas'; + Myc.Ast.Visualizer in 'Myc.Ast.Visualizer.pas'; {$R *.res} diff --git a/ASTPlayground/ASTPlayground.dproj b/ASTPlayground/ASTPlayground.dproj index 11bb4be..001d1a5 100644 --- a/ASTPlayground/ASTPlayground.dproj +++ b/ASTPlayground/ASTPlayground.dproj @@ -141,7 +141,6 @@ - Base diff --git a/ASTPlayground/MainForm.pas b/ASTPlayground/MainForm.pas index a37ebdf..2bc5648 100644 --- a/ASTPlayground/MainForm.pas +++ b/ASTPlayground/MainForm.pas @@ -22,7 +22,7 @@ uses FMX.Controls.Presentation, DraggablePanel, Myc.Ast.Visualizer, - Myc.Data.POD, + Myc.Data.Scalar, Myc.Ast.Nodes, Myc.Ast, Myc.Ast.Evaluator, @@ -77,7 +77,7 @@ implementation uses Myc.Ast.Scope, - Myc.Ast.RttiUtils, + Myc.Data.Scalar.JSON, Myc.Data.Decimal, System.Diagnostics; // For TStopwatch diff --git a/Doc/Visueller AST-Editor.md b/Doc/Visueller AST-Editor.md new file mode 100644 index 0000000..eba6298 --- /dev/null +++ b/Doc/Visueller AST-Editor.md @@ -0,0 +1,70 @@ +# **Projektplan: Visueller AST-Editor** + +* **Datum:** 02.09.2025 18:17 + +### **Motivation** + +Der bestehende AST-Visualizer soll zu einem vollwertigen, interaktiven Editor ausgebaut werden. Ziel ist es, dem Benutzer die Erstellung und Bearbeitung von ASTs auf eine rein visuelle, intuitive und fehlerresistente Weise zu ermöglichen. Eine Kernanforderung ist die Möglichkeit, AST-Strukturen von externen Tools, insbesondere LLMs, über ein JSON-Format zu importieren. + +### **Ziel** + +Die Entwicklung eines robusten visuellen Editors, bei dem der Abstract Syntax Tree (AST) zu jeder Zeit in einem syntaktisch validen Zustand ist. Der Benutzer soll durch kontextsensitive Aktionen angeleitet werden, anstatt durch freies "Verkabeln" Fehler machen zu können. Das Design muss eine saubere Trennung zwischen der logischen AST-Struktur und ihrer visuellen Repräsentation gewährleisten, um die Anbindung an externe Tools zu vereinfachen. + +### **Ergebnis: Architekturentwurf** + +Der Editor basiert auf einem Model-View-Controller-Ansatz mit einer strikten Trennung der Verantwortlichkeiten. + +**1\. Kernarchitektur: Der reine AST als Model** + +* **Source of Truth**: Der IAstNode-Baum ist das alleinige Model und die "Source of Truth". Er enthält ausschließlich die logische Struktur und die Beziehungen der Knoten untereinander. +* **Datenreinheit**: Das Model enthält keinerlei UI-spezifische Informationen wie Positionen, Farben, oder Zustände (z.B. "eingeklappt"). Diese Reinheit ist die Voraussetzung für eine einfache Serialisierung und die Interaktion mit externen Systemen. +* **Mapping**: Eine zentrale Controller-Klasse verwaltet die Zuordnung zwischen Model und View, idealerweise über ein TDictionary\. + +**2\. Layout-Engine: Deterministische Visualisierung (View \= f(AST))** + +* **Grundprinzip**: Die gesamte visuelle Darstellung wird bei jeder Änderung prozedural und deterministisch aus dem Zustand des AST-Models generiert. +* **Layout-Algorithmus**: Der bestehende Ansatz aus dem TAstToAuraNodeVisitor wird formalisiert: + 1. Für einen gegebenen Knoten werden zuerst rekursiv alle seine Input-Knoten (Kinder) von links nach rechts und oben nach unten positioniert. + 2. Anschließend wird der Eltern-Knoten rechts von den Grenzen seiner Kinder platziert, typischerweise vertikal zentriert. +* **Metadaten-Overrides**: Manuelle Änderungen am Layout durch den Benutzer (z.B. das Verschieben eines Knotens) werden als optionale Overrides behandelt. Diese werden in einer vom Model getrennten Struktur (TDictionary\) gespeichert. Beim Layout-Prozess wird für jeden Knoten zuerst geprüft, ob ein solcher Override existiert; falls nicht, wird die Position algorithmisch berechnet. + +**3\. Editier-Paradigma: Socket-basierte, geführte Bearbeitung** + +* **Ziel: "Always Valid AST"**: Jede vom Benutzer durchgeführte Aktion überführt den AST von einem validen Zustand in einen neuen validen Zustand. Syntaxfehler durch den Benutzer werden durch das Design ausgeschlossen. +* **Sockets statt Palette**: Unverbundene Input-Pins dienen als "Sockets" und sind die primären Interaktionspunkte zum Erweitern des Baumes. Es gibt keine globale Palette, aus der beliebige Knoten auf eine leere Fläche gezogen werden können. +* **Kontextsensitive Aktionen**: Ein Klick auf einen Socket öffnet ein Popup-Menü, das ausschließlich Aktionen und Knotentypen anbietet, die an dieser Stelle syntaktisch zulässig sind. +* **Refactoring-Operationen**: Die Manipulation bestehender Knoten erfolgt durch gezielte Befehle wie "Ersetzen durch...", "Löschen" (setzt auf Socket zurück) oder "Umschließen mit...". Drag & Drop dient dem Umordnen von Sequenzen oder dem Verschieben ganzer, valider Teilbäume in einen kompatiblen Socket. + +**4\. Serialisierung & LLM-Integration: Das duale Clipboard** + +* **Zwei Anwendungsfälle**: Es wird zwischen der internen Benutzererfahrung und dem externen Datenaustausch unterschieden. +* **Standard-Clipboard (Strg+C / Strg+V)**: Für die nahtlose Arbeit des Benutzers innerhalb des Editors. + * **Kopieren**: Serialisiert den ausgewählten AST-Teilbaum **inklusive** der UI-Metadaten (Layout-Overrides). + * **Einfügen**: Deserialisiert das Paket und reproduziert den visuellen Zustand 1:1. +* **Logik-Clipboard (via Kontextmenü)**: Für den robusten Austausch mit LLMs und anderen Tools. + * **"Logik als JSON kopieren"**: Serialisiert den AST-Teilbaum **ohne** jegliche UI-Metadaten in ein pures, logisches JSON-Format. + * **"Logik aus JSON einfügen"**: Deserialisiert ein pures JSON. Eventuell vorhandene, fremde Metadaten werden tolerant ignoriert. Nach dem Einfügen wird der neue Teilbaum durch die Layout-Engine automatisch positioniert. + +**5\. Undo/Redo: Das Command Pattern** + +* Jede modifizierende Aktion (Knoten erstellen, verbinden, Eigenschaft ändern) wird als IEditorCommand-Objekt mit Execute- und Unexecute-Methoden implementiert. Ein Command-Manager verwaltet die Undo/Redo-Stacks. + +### **TODO: Nächste Schritte** + +1. **Architektur-Refactoring**: + * Entkopplung der IAstNode-Struktur von der TAuraNode-View. + * Einführung einer Controller-Klasse, die das Mapping (TDictionary) und die Interaktionslogik verwaltet. +2. **Layout-Engine implementieren**: + * Formalisierung des deterministischen Layout-Algorithmus in einer wiederverwendbaren Einheit. + * Implementierung des Metadaten-Override-Systems. +3. **Command Pattern implementieren**: + * Definition der IEditorCommand-Schnittstelle. + * Implementierung der grundlegenden Command-Klassen (CreateNode, DeleteNode, ConnectNodes, SetProperty). + * Aufbau eines TCommandManager für die Verwaltung der Undo/Redo-Historie. +4. **Controller-Logik entwickeln**: + * Implementierung der Socket-Interaktion (Klick-Handler). + * Logik zur dynamischen Erzeugung der kontextsensitiven Menüs. + * Anbindung der Benutzeraktionen an das Command-System. +5. **Duales Clipboard-System umsetzen**: + * Entwicklung der JSON-Serialisierungs- und Deserialisierungsroutinen für beide Formate (mit und ohne Metadaten). + * Implementierung der entsprechenden UI-Aktionen. \ No newline at end of file diff --git a/Doc/Visuelles System für Handelsstrategien.md b/Doc/Visuelles System für Handelsstrategien.md new file mode 100644 index 0000000..8bea836 --- /dev/null +++ b/Doc/Visuelles System für Handelsstrategien.md @@ -0,0 +1,68 @@ +# **Projektplan: Visuelles System für Handelsstrategien** + +* **Datum:** 02.09.2025 18:47 + +### **Motivation** + +Ziel ist die Schaffung eines Systems, das es Fachexperten im Finanzbereich (z.B. Tradern, Analysten) ohne Programmierkenntnisse ermöglicht, komplexe Handelsstrategien interaktiv zu entwerfen, zu visualisieren, zu debuggen und zu backtesten. Die traditionelle Hürde der textbasierten Programmierung soll durch einen rein visuellen, geführten Ansatz eliminiert werden. Das System muss erweiterbar sein und eine robuste Schnittstelle für den Import von Logik aus externen Quellen wie LLMs bieten. + +### **Ziel** + +Die Entwicklung einer dualen Systemarchitektur, die eine intuitive, fehlerresistente Entwicklungsumgebung von einer hochperformanten Backtesting-Engine trennt. Der Benutzer interagiert mit einer High-Level-Repräsentation seiner Strategie (HAST), die für die Ausführung in eine optimierte Low-Level-Repräsentation (CAST) übersetzt wird. Dies ermöglicht eine reichhaltige Debugging-Erfahrung bei gleichzeitig maximaler Performance für datenintensive Backtests. + +### **Ergebnis: Detaillierter Architekturentwurf** + +Die Architektur besteht aus zwei primären Ausführungsmodi (**Debug-Modus** und **Backtest-Modus**), die auf unterschiedlichen Repräsentationen des AST und spezialisierten Engines operieren. + +**1\. Der High-Level AST (HAST) \- Die Welt des Benutzers** + +* **Rolle**: Die alleinige "Source of Truth" für die visuelle Darstellung und die interaktive Bearbeitung. Der HAST ist die Repräsentation, die der Benutzer sieht und manipuliert. +* **Struktur**: Ein Baum aus IAstNode-Interfaces. Er enthält eine Mischung aus primitiven Knoten (die direkt einer nativen Operation entsprechen) und zusammengesetzten Knoten (vom Benutzer erstellte "Funktionen" oder Sub-Graphen). +* **Editor-Interaktion**: Der visuelle Editor arbeitet ausschließlich auf dem HAST. Die Bearbeitung ist strukturell und geführt: + * **Sockets**: Unverbundene Input-Pins sind die einzigen Stellen, an denen der Baum erweitert werden kann. + * **Kontext-sensitive Menüs**: Ein Klick auf ein Socket bietet nur syntaktisch zulässige Knoten und Aktionen an, was Fehler von vornherein verhindert. + * **Gültigkeit**: Der HAST befindet sich zu jedem Zeitpunkt in einem strukturell validen Zustand. +* **Erweiterbarkeit**: Benutzer können neue HAST-Knoten durch visuelle Komposition erstellen ("Zu Funktion zusammenfassen"). Dies ist der primäre Mechanismus zur Schaffung von Wiederverwendbarkeit und Abstraktion für den Endanwender. + +**2\. Der Core AST (CAST) \- Die Welt der Engine** + +* **Rolle**: Eine optimierte, "flache" Zwischenrepräsentation der Strategie, die speziell für die High-Performance-Engine konzipiert ist. Man kann sie als den "Maschinencode" des Systems betrachten. +* **Struktur**: Ein Graph, der ausschließlich aus einem minimalen Satz von primitiven Knoten besteht. Jeder CAST-Knoten entspricht einer direkten, in nativem Delphi-Code implementierten, hochoptimierten Operation. Konzepte wie "Benutzerfunktion" oder "Sub-Graph" existieren auf dieser Ebene nicht mehr. + +**3\. Die zwei Ausführungs-Engines** + +* **Engine A: Der HAST-Interpreter (Der Debugger)** + * **Modus**: Wird im interaktiven **Debug-Modus** verwendet. (Dies entspricht dem aktuell existierenden Evaluator). + * **Funktionsweise**: Arbeitet direkt auf dem HAST. Er ist langsamer, da er die Logik für das "Betreten" und "Verlassen" von zusammengesetzten Knoten (Funktionsaufrufe) zur Laufzeit interpretieren muss. + * **Features**: Eng mit der UI gekoppelt, um eine reichhaltige Debugging-Erfahrung zu ermöglichen: Visuelle Hervorhebung des aktuellen Knotens, Breakpoints, Step-Into/Over/Out, Live-Inspektion der Daten auf den Verbindungen und detailliertes Logging. +* **Engine B: Der CAST-Evaluator (Der Backtester)** + * **Modus**: Wird im **Backtest-Modus** für die Massenverarbeitung von Daten verwendet. + * **Funktionsweise**: Arbeitet ausschließlich auf dem CAST. Er wird durch einen vorgeschalteten **HAST \-\> CAST Expander** (ein spezieller Visitor) gespeist, der den HAST in den optimierten CAST übersetzt. + * **Features**: Eine "Headless"-Engine ohne UI-Anbindung. Ihre einzige Aufgabe ist die maximale Ausführungsgeschwindigkeit. Sie kennt keine Breakpoints oder detailliertes Logging und gibt am Ende nur das finale Ergebnis (z.B. Trade-Listen, Performance-Metriken) zurück. + +**4\. Serialisierung & Externe Integration** + +* **Duales Clipboard**: Um sowohl die interne Usability als auch die externe Anbindung optimal zu unterstützen, werden zwei Clipboard-Mechanismen implementiert. + * **Standard-Clipboard (Strg+C/V)**: Kopiert den HAST-Teilbaum **inklusive** der optionalen UI-Metadaten (manuelle Knotenpositionen etc.), um ein perfektes visuelles Duplikat für den Benutzer zu erstellen. + * **Logik-Clipboard (via Kontextmenü)**: Kopiert/einfügt einen **puren HAST** als JSON ohne jegliche UI-Metadaten. Dies ist die saubere, robuste Schnittstelle für die Interaktion mit LLMs und anderen Tools. + +### **TODO: Roadmap für die Implementierung** + +1. **Fundament (Editor & HAST)** + * Finalisierung der IAstNode-Struktur für den HAST. + * Implementierung des Socket-basierten Editier-Controllers mit kontextsensitiven Menüs. + * Umsetzung des Command Patterns für alle AST-modifizierenden Aktionen (Undo/Redo). + * Implementierung der visuellen "Zu Funktion zusammenfassen"-Logik. + * Aufbau des separaten Speichers für UI-Metadaten-Overrides. +2. **Engine 1 (HAST-Interpreter / Debugger)** + * Ausbau des bestehenden Evaluators zum vollwertigen HAST-Interpreter. + * Tiefe Integration mit der UI zur Realisierung der Debugging-Features (Breakpoints, Step-Logik, Daten-Hover etc.). +3. **Engine 2 (CAST-Evaluator / Backtester)** + * Definition des minimalen Satzes an primitiven Knoten für den CAST. + * Implementierung der hochperformanten, nativen Delphi-Operationen für jeden CAST-Knoten. + * Entwicklung des HAST-zu-CAST-Expander-Visitors. + * Erstellung des "headless" CAST-Evaluators, der den CAST entgegennimmt und die Ergebnisse zurückliefert. +4. **Werkzeuge & Integration** + * Implementierung der beiden JSON-Serialisierungs-Routinen (mit/ohne Metadaten). + * Integration der Clipboard-Aktionen in die UI. + * Aufbau der "Standardbibliothek" mit nützlichen, vordefinierten HAST-Knoten. \ No newline at end of file diff --git a/Src/AST/Myc.Ast.Evaluator.pas b/Src/AST/Myc.Ast.Evaluator.pas index 6005843..f065cd5 100644 --- a/Src/AST/Myc.Ast.Evaluator.pas +++ b/Src/AST/Myc.Ast.Evaluator.pas @@ -6,7 +6,7 @@ uses System.SysUtils, System.Classes, // For TStrings System.Generics.Collections, - Myc.Data.POD, + Myc.Data.Scalar, Myc.Ast.Nodes, Myc.Ast; @@ -74,7 +74,7 @@ uses Myc.Data.Decimal, Myc.Ast.Scope, Myc.Ast.Printer, - Myc.Ast.RttiUtils; // Added for JsonToRecordDefinition + Myc.Data.Scalar.JSON; // Added for JsonToRecordDefinition type // The signature for a native Delphi function callable from the script. diff --git a/Src/AST/Myc.Ast.Nodes.pas b/Src/AST/Myc.Ast.Nodes.pas index 93340e1..e7f5028 100644 --- a/Src/AST/Myc.Ast.Nodes.pas +++ b/Src/AST/Myc.Ast.Nodes.pas @@ -5,7 +5,7 @@ interface uses System.SysUtils, System.Generics.Collections, - Myc.Data.POD; + Myc.Data.Scalar; type // Operators and helpers diff --git a/Src/AST/Myc.Ast.Printer.pas b/Src/AST/Myc.Ast.Printer.pas index be8b2da..af5c112 100644 --- a/Src/AST/Myc.Ast.Printer.pas +++ b/Src/AST/Myc.Ast.Printer.pas @@ -40,7 +40,7 @@ type implementation uses - Myc.Data.POD, + Myc.Data.Scalar, Myc.Data.Decimal; { TPrettyPrintVisitor } diff --git a/Src/AST/Myc.Ast.pas b/Src/AST/Myc.Ast.pas index de3f015..2647937 100644 --- a/Src/AST/Myc.Ast.pas +++ b/Src/AST/Myc.Ast.pas @@ -4,7 +4,7 @@ interface uses System.SysUtils, - Myc.Data.POD, + Myc.Data.Scalar, Myc.Ast.Nodes; type diff --git a/ASTPlayground/Myc.Ast.RttiUtils.pas b/Src/Data/Myc.Data.Scalar.JSON.pas similarity index 95% rename from ASTPlayground/Myc.Ast.RttiUtils.pas rename to Src/Data/Myc.Data.Scalar.JSON.pas index 2b692f1..aad5714 100644 --- a/ASTPlayground/Myc.Ast.RttiUtils.pas +++ b/Src/Data/Myc.Data.Scalar.JSON.pas @@ -1,4 +1,4 @@ -unit Myc.Ast.RttiUtils; +unit Myc.Data.Scalar.JSON; interface @@ -6,7 +6,7 @@ uses System.SysUtils, System.Rtti, System.TypInfo, - Myc.Data.POD; + Myc.Data.Scalar; type TRttiAstHelper = class @@ -24,6 +24,7 @@ implementation uses Myc.Data.Decimal, + System.Generics.Collections, System.JSON; { TRttiAstHelper } diff --git a/Src/Data/Myc.Data.POD.pas b/Src/Data/Myc.Data.Scalar.pas similarity index 96% rename from Src/Data/Myc.Data.POD.pas rename to Src/Data/Myc.Data.Scalar.pas index 3db82e0..93f9a82 100644 --- a/Src/Data/Myc.Data.POD.pas +++ b/Src/Data/Myc.Data.Scalar.pas @@ -1,4 +1,4 @@ -unit Myc.Data.POD; +unit Myc.Data.Scalar; interface @@ -160,8 +160,6 @@ type end; TScalarMemberSeries = record - strict private - FKind: TScalarKind; private FDef: TScalarRecordDefinition; FArray: TChunkArray;