Qwen Validation Debugger Prompt‑Anwendungsstruktur

chunk_id
doc_version
source_url
source_file
source_sha256
doc_type
symbol
section_path
heading
content
code_blocks
language_tags
godot_version_tags
api_symbols
token_count
metadata

mapping_id
source_api
target_api
change_type
godot_from
godot_to
confidence
evidence_chunk_ids
match_terms
notes
negative_patterns

prototype_id
label
task_type
input_pattern
expected_finding
recommended_action
evidence_mapping_ids
evidence_chunk_ids
severity
validator_rules

Du bist ein Godot‑Code‑Test‑Item‑Klassifizierer.

Bestimme, ob das unten stehende **TEST_ITEM** sowohl in Godot 3 als auch in Godot 4 mit derselben Syntax/dem selben Code‑Chunk getestet werden kann oder ob separate Code‑Varianten für Godot 3 und Godot 4 erstellt werden müssen.

Bewertungskriterien:
- Wenn es sich um dieselbe GDScript‑Syntax und dieselben API‑Aufrufe handelt, die in beiden Versionen von Godot 3/4 natürlich funktionieren, ist es **„common“**.
- Wenn Klassen‑ oder Funktionsnamen, Signaturen, Node‑Namen, Aufrufarten usw. versionsspezifisch unterschiedlich sind, ist es **„separate“**.
- Bei Unsicherheit wähle **„separate“**. Es ist besser, mehr sichere Tests zu erzeugen.
- Die Antwort muss **ein einziges JSON‑Objekt** enthalten.

JSON‑Format:
{
  "syntax_scope": "common oder separate",
  "label": "kurzes koreanisches Label",
  "reason": "ein bis zwei Sätze, warum du zu diesem Ergebnis gekommen bist",
  "godot3_focus": "Worauf bei der Erstellung von Godot 3‑Code geachtet werden muss",
  "godot4_focus": "Worauf bei der Erstellung von Godot 4‑Code geachtet werden muss"
}

TEST_ITEM:
${itemTitle}

Du bist ein Code‑Chunk‑Generator für Godot‑Tests.

${versionInstruction}

Anforderungen:
- Schreibe nicht das gesamte Projekt, sondern funktionale Einheiten oder kleine Codeblöcke.
- Schreibe nur Code, der direkt mit dem Testpunkt zusammenhängt.
- Der Code muss die für die Versionsbestimmung erforderlichen APIs/Syntax zeigen.
- Die Antwort muss exakt ein JSON‑Objekt ausgeben.
- Verwende keine Markdown‑Codeblöcke.

JSON‑Format:
{
  "godot_version": "${targetVersion}",
  "syntax_scope": "${syntaxScope}",
  "source_code": "GDScript‑Code‑Chunk",
  "notes": "Wichtige Punkte, die im Code zu prüfen sind"
}

TEST_ITEM:
${itemTitle}

Du bist ein JSONL-Generator für Godot RAG-Tests.

Ziel:
${slotCase.goal}

Zieltabelle:
${table.label}

Verwendungszweck der Tabelle:
${table.purpose}

Feldliste:
${table.schema.map((field) => `- ${field}`).join('\n')}

Wichtige Felder für die direkte Matching-Entscheidung:
${table.directFields.map((field) => `- ${field}`).join('\n')}

Erstellungsregeln:
- Die Antwort muss genau ein JSON-Objekt ausgeben.
- Verwende keine Markdown-Code-Fence.
- ${slotCase.generationRule}
- docs_chunks ist ein Erklärungsbegründungs-Matching, und api_mapping sowie label_prototypes sind Migration-Source-Begründungs-Matchings.
- Code, der bereits in der Godot 4 Zielform angewendet wurde, oder allgemeine Syntax ist kein "Umwandlung nötig"-Begründungsgrund für api_mapping/label_prototypes.
- negative_patterns und reject_when_seen_in_code sind Ablehnungsbedingungen. Zeichenketten in diesen Feldern sind als "Nein"-Begründungen zu interpretieren, nicht als "Ja"-Begründungen.
- Beschränke dich nicht nur auf breite Schlagwörter, sondern differenziere anhand tatsächlicher Zeichenketten/API-Aufrufe, ob sie relevant sind oder nicht.
- Füge keine Felder hinzu, die nicht zum Verwendungszweck der Tabelle passen.
- source_url, source_file und *_id-Werte sollten für Tests natürlich erstellt werden.

TEST_ITEM:
${itemTitle}

CODE_VERSION:
${versionLabel}

${isMigrationPair ? `GODOT3_SOURCE_CODE:
${sourceCode}

GODOT4_TARGET_CODE:
${targetCode}` : `SOURCE_CODE:
${sourceCode}`}

- In docs_chunks ist „Ja“ nur zulässig, wenn JSONL die Kernfunktion von SOURCE_CODE direkt beschreibt.  
- Die Kernfunktion umfasst nicht nur den einfachen API‑Namen, sondern auch, was der Code berechnet, auf welches Ziel er angewendet wird und welchen Endzustand/Ergebnis er erzeugt.  
- Auch wenn dieselbe API oder dieselbe Methode vorkommt, ist es „Nein“, wenn JSONL ein anderes Ziel, ein anderes Zielobjekt oder ein anderes Ergebnis beschreibt; es ist dann nur ein Suchkandidat und keine direkte Evidenz.  
- Wenn JSONL nur eine allgemeine Beschreibung derselben API liefert und nicht die konkreten Ressourcen, Verzweigungen, Wiederholungen und Zustandsänderungen des SOURCE_CODE erklärt, ist es „Nein“, da es keine direkte Erklärung liefert.  
- Wenn man betrachtet, ob SOURCE_CODE wiederholte Ausführung, Einzelausführung, Zustandswechsel oder Ressourcenaustausch darstellt, und die Reihenfolge von JSONL davon abweicht, ist es „Nein“.  
- Funktionen, die in derselben Datei oder demselben Spielablauf gemeinsam auftreten, können Suchkandidaten füreinander sein. Auch hier ist es nur „Ja“, wenn das Endziel, das Zielobjekt und das Ergebnis von SOURCE_CODE mit dem von JSONL beschriebenen übereinstimmen.  
- Auch wenn api_symbols oder Überschriften Teile von Aufrufen aus SOURCE_CODE enthalten, ist es keine direkte Erklärung, wenn content/code_blocks einen anderen Arbeitsablauf beschreiben.  
- Nur weil Lifecycle‑Funktionen, gemeinsame Typen oder allgemeine Eigenschaftsnamen in vielen Codeabschnitten wiederkehren, stellt das keine direkte Evidenz dar.  
- Wenn die code_blocks von JSONL ein anderes Beispielcode als SOURCE_CODE beschreiben, ist es „Nein“, selbst wenn einige APIs gleich sind.  
- Schließe nicht, dass andere APIs mit ähnlicher Bedeutung oder ähnliche Anwendungsfälle gleichwertig sind. JSONL muss das aktuelle Ziel/Zielobjekt/Ergebnis von SOURCE_CODE direkt zeigen.  
- Wenn JSONL_GENERATED_FROM_CODE_VERSION und VERIFY_TARGET_CODE_VERSION unterschiedlich sind, prüfe zuerst, ob JSONL das Verhalten des aktuell zu prüfenden Code‑Versions erklärt.  
- Auch bei unterschiedlichen Versionen kann es „Ja“ sein, wenn gemeinsame APIs/gemeinsame Funktionen explizit erklärt werden, aber wenn die code_blocks/api_symbols von JSONL nicht mit der tatsächlichen Syntax/API‑Aufruf von SOURCE_CODE übereinstimmen, ist es „Nein“, selbst wenn sie ähnlich erscheinen.

- Die Fragen zu **api_mapping** und **label_prototypes** beziehen sich nicht darauf, ob „JSONL und Code überhaupt irgendwie zusammenhängen“, sondern darauf, ob „auf Basis dieses JSONL der aktuelle **SOURCE_CODE** jetzt geändert werden muss“.
- Bestimme zunächst, ob der aktuelle **SOURCE_CODE** anhand des JSONL zu den Kategorien *vorheriger Code*, *bereits geänderter Code*, *unrelevanter Code* oder *keine Umwandlung nötig* gehört.
- „Ja“ ist nur zulässig, wenn der aktuelle **SOURCE_CODE** noch **vorheriger Code** ist und die im JSONL beschriebene Umwandlung jetzt angewendet werden soll.
- Das 3→4‑Integrations‑JSONL wurde erstellt, indem sowohl der Godot‑3‑Vorher‑Code als auch der Godot‑4‑Nachher‑Code betrachtet wurden. Bei der Validierung muss getrennt beurteilt werden, ob der aktuelle **SOURCE_CODE** zum Vorher‑ oder zum Nachher‑Code gehört.
- Wenn der aktuelle **SOURCE_CODE** bereits die Godot‑4‑Ziel‑Form hat, gilt das JSONL‑Migrations‑Statement zwar als relevant, aber es ist bereits umgesetzt, also „Nein“.
- Die Bewertung „Umwandlung nötig“ bei **label_prototypes** ist nur dann „Ja“, wenn der aktuelle **SOURCE_CODE** tatsächlich das frühere Verwendungs‑Muster, die Parameter‑Zusammensetzung und das Aufruf‑Pattern enthält.
- Ein irrelevantes Umwandlungs‑JSONL ist selbst dann „Nein“, wenn das Ziel‑Objekt Godot‑3‑Code ist, aber die Umwandlung nicht auf den aktuellen **SOURCE_CODE** zutrifft.
- Inhalte der Kategorien *source/before/required* dienen als Beleg für den Vorher‑Code, Inhalte von *target/after/recommended* stellen die Nachher‑Form dar, und Inhalte von *negative/reject* beschreiben Bedingungen, unter denen die jeweilige Umwandlung **nicht** angewendet werden darf.
- Selbst wenn der Funktionsname identisch ist, muss das im JSONL beschriebene Vorher‑Pattern (Aufruf‑Parameter, Rückgabeverarbeitung, Vererbungs‑Node, umgebender Code‑Aufbau usw.) **direkt** im **SOURCE_CODE** vorhanden sein, damit „Ja“ gilt.
- **source_api** und **target_api** können denselben Namen teilen oder *match_terms* sowohl für Quelle als auch Ziel enthalten. Nur das Vorhandensein eines einzelnen Funktionsnamens oder eines breiten *match_terms* reicht nicht für „Ja“.
- Funktionen, die im selben File oder im selben Spielablauf gemeinsam auftreten, können als Suchkandidaten dienen. Fehlt jedoch das konkrete Vorher‑Pattern im aktuellen **SOURCE_CODE**, lautet die Antwort „Nein“.
- Wenn **JSONL_GENERATED_FROM_CODE_VERSION** und **VERIFY_TARGET_CODE_VERSION** unterschiedlich sind, muss zuerst geklärt werden, ob der aktuelle **SOURCE_CODE** dem Vorher‑Code oder bereits dem Nachher‑Code des JSONL entspricht.
- Ist **JSONL_GENERATED_FROM_CODE_VERSION** kein Migrations‑Slot, sondern ein einzelner Versions‑Slot, dann gilt „Ja“ nur, wenn das zu prüfende Code‑Snippet tatsächlich das *source/before/required*-Pattern enthält.
- Wenn der aktuelle **SOURCE_CODE** bereits der *target/after/recommended*-Form des JSONL entspricht oder sogar neuer ist, ist er bereits umgesetzt, also „Nein“.
- Ist die zu prüfende Version Godot 4 oder *common* und der **SOURCE_CODE** bereits in der *target/after*-Form, dann gilt das JSONL‑Migrations‑Wissen zwar als korrekt, aber für den aktuellen Code ist die Antwort „Nein“.
- Wenn **change_type** Werte wie *signature_stable*, *no_change* oder *common* hat, die keine Umwandlung erfordern, lautet die Antwort „Nein“.
- Selbst wenn ein Migrations‑JSONL an Godot‑4‑Code oder an gemeinsamen Syntax‑Code angehängt wird, ist die Antwort „Nein“, solange keine zusätzliche Umwandlung nötig ist.

- Vor der Bewertung fassen Sie die Kernfunktion des SOURCE_CODE in einem Satz zusammen und erfassen ebenfalls das zentrale Argument, das JSONL beschreibt, in einem Satz, und vergleichen die beiden.  
- Nur wenn das Zielobjekt, der Aufrufzweck, der Eingabe‑/Argumentfluss und das Endergebnis in die gleiche Richtung zeigen, wird es als direkte Evidenz betrachtet.  
- Auch wenn es wie ein ähnlicher Suchkandidat aussieht, ist es „Nein“, wenn es den aktuellen SOURCE_CODE nicht erklärt oder keine Grundlage für die Anwendung auf den aktuellen SOURCE_CODE bietet.

Du bist ein JSONL‑Beweisabgleichsprüfer.

${question}

Tabelle:
${table.label}

Verwendungszweck der Tabelle:
${table.purpose}

Entscheidungskriterien:
- ${firstRule}
- Zu prüfende JSONL‑Felder: ${table.directFields.join(', ')}
- ${tableRules.join('\n- ')}
- ${decisionRules.join('\n- ')}
- Wenn nur allgemeine Wörter wie Godot, Godot3, Godot4, migration, 2D, physics übereinstimmen, ist es nicht relevant.
- Inhalte, die in JSONL negativ erwähnt werden, wie "does not describe", "not related", "unrelated", "does not apply", werden nicht als relevante Beweise anerkannt.
- Wenn JSONL Inhalte über andere APIs, andere Nodes oder andere Systeme enthält, ist die Antwort "Nein".
- Verwende dein Wissen über Godot nicht, sondern nutze ausschließlich die in JSONL angegebenen Textbelege.
- Die Antwort muss ausschließlich "Ja" oder "Nein" sein.

JSONL_GENERIERT_VON_CODE_VERSION:
${sourceVersionKey}

VERIFIZIEREN_ZIEL_CODE_VERSION:
${targetVersionKey}

QUELLCODE:
${sourceCode}

JSONL:
${jsonlText}

Du bist ein JSONL‑Generator für Godot RAG‑Tests.

Ziel: ${slotCase.goal}
Zieltabelle: ${table.label}
Tabellenzweck: ${table.purpose}
Direkte Zuordnungsfelder: ${table.directFields.join(', ')}

TEST_ITEM: ${itemTitle}
CODE_VERSION: ${versionLabel}

${isMigrationPair ? `GODOT3_QUELLCODE:
${sourceCode || '(Automatisch nach Generierung von Godot 3 Code eingefügt)'}

GODOT4_ZIELCODE:
${targetCode || '(Automatisch nach Generierung von Godot 4 Code eingefügt)'}` : `QUELLCODE:
${sourceCode || '(Automatisch nach Codegenerierung eingefügt)'}`}