fix(python): output-prompt emitter — nested field.object crashed gen/verify (#144)

The nested-object branch appended an inline `# FR-010: nested prompt deferred`
comment to the emitted PromptField literal. spec_literal joins every field onto ONE
line, so the Python '#' swallowed the rest of the line — including the closing '])' —
emitting invalid Python (unterminated list, 'SyntaxError: [ was never closed'), which
hard-crashed `gen` + `verify --codegen` (not just a diff) for any template.output
whose payload has a nested field.object. The note now lives in the function source; the
emitted literal carries no comment. (Python-only: TS/Java/Kotlin/C# use inline-safe
/* */ block comments.) PromptField already defaults nested=None, so the placeholder is
both valid syntax + constructible.

Regression test fails pre-fix (SyntaxError), passes post-fix; FR-010 suite green.


Claude-Session: https://claude.ai/code/session_01GF9xLEQZaPus5Y6opk398n

Co-authored-by: Doug Mealing <noreply@anthropic.com>

Author: dmealing

server/python/src/metaobjects/codegen/output_format_spec_emitter.py

@@ -44,10 +44,14 @@ def _prompt_field_literal(field: MetaData) -> str:
     array = "True" if fm.is_array(field) else "False"
 
     if field.sub_type == fc.FIELD_SUBTYPE_OBJECT:
-        return (
-            f'PromptField("{name}", FieldKind.OBJECT, {req}, array={array})'
-            "  # FR-010: nested prompt deferred"
-        )
+        # FR-010: nested prompt deferred — emit a FieldKind.OBJECT placeholder (nested
+        # defaults to None on PromptField). The note lives HERE, not in the returned
+        # literal: spec_literal joins every field onto ONE line, and a Python '#' inline
+        # comment would swallow the rest of that line — including the closing `])` — so a
+        # nested-object payload emitted invalid Python (unterminated list) and crashed
+        # `gen` + `verify --codegen`. The other ports use `/* */` block comments, which
+        # are inline-safe; Python has none, so the literal must carry no comment.
+        return f'PromptField("{name}", FieldKind.OBJECT, {req}, array={array})'
 
     example = _opt_string_attr(field, fc.FIELD_ATTR_EXAMPLE)
     instruction = _opt_string_attr(field, fc.FIELD_ATTR_INSTRUCTION)

server/python/tests/codegen/test_fr010_nested_object_prompt.py

@@ -0,0 +1,59 @@
+"""Regression: a ``template.output`` payload with a NESTED ``field.object`` must emit
+VALID Python from the output-prompt spec emitter (a ``FieldKind.OBJECT`` placeholder),
+NOT crash ``gen`` / ``verify --codegen``.
+
+The bug (0.15.0): the nested-object branch appended an inline ``# FR-010: nested prompt
+deferred`` comment to the emitted literal. ``spec_literal`` joins every field onto ONE
+line, so the Python ``#`` swallowed the rest of the line — including the closing ``])`` —
+producing an unterminated list (``SyntaxError: '[' was never closed``). The other four
+ports use ``/* */`` block comments, which are inline-safe; Python has none, so the literal
+must carry no comment.
+"""
+from __future__ import annotations
+
+import ast
+
+import metaobjects.core_types  # noqa: F401 — side-effect: registers attr classes
+from metaobjects.codegen import output_format_spec_emitter as ofs
+from metaobjects.meta.core.field import field_constants as fc
+from metaobjects.meta.core.field.meta_field import MetaField
+from metaobjects.meta.core.object.meta_object import MetaObject
+from metaobjects.meta.template import template_constants as tc
+from metaobjects.meta.template.meta_template import MetaTemplate
+from metaobjects.shared.base_types import TYPE_FIELD, TYPE_OBJECT, TYPE_TEMPLATE
+
+
+def _envelope() -> tuple[MetaObject, MetaTemplate]:
+    before = MetaField(TYPE_FIELD, fc.FIELD_SUBTYPE_STRING, "before")
+    before.set_attr(fc.FIELD_ATTR_REQUIRED, True)
+    # the nested object sits BETWEEN two scalars, so a swallowed line would eat both the
+    # trailing field and the closing bracket.
+    inner = MetaField(TYPE_FIELD, fc.FIELD_SUBTYPE_OBJECT, "inner")
+    inner.set_attr(fc.FIELD_ATTR_REQUIRED, True)
+    after = MetaField(TYPE_FIELD, fc.FIELD_SUBTYPE_STRING, "after")
+
+    vo = MetaObject(TYPE_OBJECT, "value", "Envelope")
+    vo.package = "acme::ai"
+    for f in (before, inner, after):
+        vo.add_child(f)
+
+    tmpl = MetaTemplate(TYPE_TEMPLATE, tc.TEMPLATE_SUBTYPE_OUTPUT, "EnvOutput")
+    tmpl.set_attr(tc.TEMPLATE_ATTR_PAYLOAD_REF, "Envelope")
+    tmpl.set_attr(tc.TEMPLATE_ATTR_FORMAT, "xml")
+    tmpl.set_attr(tc.TEMPLATE_ATTR_PROMPT_STYLE, "guide")
+    return vo, tmpl
+
+
+def test_nested_object_payload_emits_parseable_python() -> None:
+    vo, tmpl = _envelope()
+    lit = ofs.spec_literal(vo, tmpl, "Envelope")
+
+    # 1) the whole OutputFormatSpec(...) literal must be valid Python — the core bug.
+    ast.parse(lit)  # raised "SyntaxError: '[' was never closed" on the broken output
+
+    # 2) the nested field is a FieldKind.OBJECT placeholder …
+    assert "FieldKind.OBJECT" in lit
+    # 3) … with NO inline comment in the emitted literal (that was the swallow) …
+    assert "#" not in lit
+    # 4) … and the field AFTER the nested one survived (was not commented out).
+    assert '"after"' in lit