@metaobjectsdev/codegen-ts 0.7.0 → 0.8.0

package/src/templates/output-prompt.ts

@@ -0,0 +1,88 @@
+// server/typescript/packages/codegen-ts/src/templates/output-prompt.ts
+//
+// Per-template renderer for the FR-010 artifact-1 output-format prompt fragment
+// ("produce your answer like this"). For each json/xml `template.output` whose
+// @payloadRef resolves to a value-object, emits a `<TemplateName>.prompt.ts` file
+// exporting `render<TemplateName>Format(overrides?)` backed by the render engine's
+// renderOutputFormat(). The baked OutputFormatSpec's rootName is the payload name,
+// so the prompt fragment and the recover() codegen agree on the root name.
+//
+// Mirrors the C# OutputPromptGenerator + OutputFormatSpecEmitter (split into a
+// generator factory + this pure renderer, matching the TS output-parser shape).
+
+import {
+  type MetaData,
+  TYPE_OBJECT,
+  TYPE_TEMPLATE,
+  TEMPLATE_SUBTYPE_OUTPUT,
+  TEMPLATE_ATTR_PAYLOAD_REF,
+  TEMPLATE_ATTR_FORMAT,
+} from "@metaobjectsdev/metadata";
+import { specLiteral } from "./output-format-spec-emitter.js";
+
+function findObject(root: MetaData, name: string): MetaData | undefined {
+  return root.ownChildren().find((c) => c.type === TYPE_OBJECT && c.name === name);
+}
+
+function findTemplate(root: MetaData, name: string): MetaData | undefined {
+  return root.ownChildren().find((c) => c.type === TYPE_TEMPLATE && c.name === name);
+}
+
+/** True iff the template.output's @format is json or xml (the renderable structured formats). */
+export function templateSupportsPrompt(tmpl: MetaData): boolean {
+  const f = ((tmpl.ownAttr(TEMPLATE_ATTR_FORMAT) as string | undefined) ?? "text").toLowerCase();
+  return f === "json" || f === "xml";
+}
+
+/**
+ * Render the full output-prompt file for one json/xml `template.output` node.
+ * Throws if the template isn't found, isn't a template.output, isn't json/xml,
+ * or its @payloadRef doesn't resolve to an object.value.
+ */
+export function renderOutputPrompt(root: MetaData, templateName: string): string {
+  const tmpl = findTemplate(root, templateName);
+  if (!tmpl) {
+    throw new Error(`template "${templateName}" not found in metadata root`);
+  }
+  if (tmpl.subType !== TEMPLATE_SUBTYPE_OUTPUT) {
+    throw new Error(`template "${templateName}" is not a template.output (got subtype "${tmpl.subType}")`);
+  }
+  if (!templateSupportsPrompt(tmpl)) {
+    throw new Error(`template "${templateName}" @format is not json/xml — no prompt fragment`);
+  }
+  const payloadRef = tmpl.ownAttr(TEMPLATE_ATTR_PAYLOAD_REF);
+  if (typeof payloadRef !== "string") {
+    throw new Error(`template "${templateName}" missing @payloadRef`);
+  }
+  const vo = findObject(root, payloadRef);
+  if (!vo) {
+    throw new Error(`template "${templateName}" @payloadRef "${payloadRef}" not found in metadata root`);
+  }
+
+  // rootName == payload name so the prompt fragment and recover() agree.
+  const spec = specLiteral(vo, tmpl, payloadRef);
+  const specName = `${templateName}FormatSpec`;
+  const fnName = `render${templateName}Format`;
+
+  return `import {
+  renderOutputFormat,
+  Format,
+  FieldKind,
+  PromptStyle,
+  type OutputFormatSpec,
+  type PromptOverrides,
+} from "@metaobjectsdev/render";
+
+const ${specName}: OutputFormatSpec = ${spec};
+
+/**
+ * The output-format instruction fragment for the ${templateName} template.output
+ * ("produce your answer like this"). Comment-free — guidance lives in prose /
+ * inline placeholders / a filled skeleton. Pass \`overrides\` to override the style
+ * or per-field example/instruction at render time.
+ */
+export function ${fnName}(overrides?: PromptOverrides): string {
+  return renderOutputFormat(${specName}, overrides ?? {});
+}
+`;
+}

package/src/templates/recover-schema-emitter.ts

@@ -0,0 +1,91 @@
+// server/typescript/packages/codegen-ts/src/templates/recover-schema-emitter.ts
+//
+// Turns a payload value-object into TS source fragments for the FR-010 recover codegen:
+//   • schemaLiteral     — a `recoverSchema(Format.JSON, "root", [ … ])` baked descriptor
+//                         built from FieldSpec factories (scalar / enumField).
+//   • mirrorInterface   — an all-nullable mirror interface `<Payload>Recovered` (each
+//                         component `T | null`); recover returns this nullable twin rather
+//                         than the strict payload (same reasoning as the Java/C#/Kotlin ports).
+//   • mirrorInitializer — `{ prop: asString(d, "prop"), … }` building the mirror from the
+//                         forgiving outcome map `d`.
+//
+// Mirrors the C# RecoverSchemaEmitter (adapted to TS syntax + the `| null` nullable mirror).
+// Bounded scope: scalar / enum / scalar-array. Nested object + array-of-enum deferred.
+
+import {
+  type MetaData,
+  FIELD_SUBTYPE_ENUM,
+  FIELD_SUBTYPE_OBJECT,
+  FIELD_ATTR_ENUM_ALIAS,
+} from "@metaobjectsdev/metadata";
+import {
+  fields,
+  isRequired,
+  isArray,
+  scalarKind,
+  mirrorType,
+  recoverMapCall,
+  enumValues,
+  jsonStringLiteral,
+  stringArrayLiteral,
+  propertiesMapLiteral,
+} from "./fr010-field-mapping.js";
+
+/** Emit `recoverSchema(Format.X, "rootName", [ … ])`. */
+export function schemaLiteral(vo: MetaData, format: string, rootName: string): string {
+  const formatEnum = format.toLowerCase() === "xml" ? "Format.XML" : "Format.JSON";
+  const specs = fields(vo).map(fieldSpecLiteral);
+  return `recoverSchema(${formatEnum}, ${jsonStringLiteral(rootName)}, [${specs.join(", ")}])`;
+}
+
+function fieldSpecLiteral(field: MetaData): string {
+  const name = jsonStringLiteral(field.name);
+  const required = isRequired(field);
+
+  if (field.subType === FIELD_SUBTYPE_ENUM) {
+    const valuesLit = stringArrayLiteral(enumValues(field));
+    const aliasLit = propertiesMapLiteral(field.ownAttr(FIELD_ATTR_ENUM_ALIAS));
+    // enumField() sets array:false; enum-array is a bounded deferral (parity with Java/C#).
+    return `enumField(${name}, ${required}, ${valuesLit}, ${aliasLit})`;
+  }
+
+  if (field.subType === FIELD_SUBTYPE_OBJECT) {
+    // FR-010: nested recover deferred — treat as an opaque required/optional string slot.
+    return `scalar(${name}, FieldKind.STRING, ${required}) /* FR-010: nested recover deferred */`;
+  }
+
+  const kind = scalarKind(field.subType) ?? "STRING";
+  // Scalar-array: the scalar() factory only builds singular specs (array:false), so emit a
+  // FieldSpec object literal with array:true. Tier-2 win over the Roslyn proof: the emitted
+  // recover() actually populates the array at runtime (RecoverMap.asStringList).
+  if (isArray(field)) {
+    return (
+      `{ name: ${name}, kind: FieldKind.${kind}, required: ${required}, array: true, ` +
+      `enumValues: null, enumAlias: null, min: null, max: null, nested: null }`
+    );
+  }
+  return `scalar(${name}, FieldKind.${kind}, ${required})`;
+}
+
+/** Emit the all-nullable mirror interface declaration. */
+export function mirrorInterface(vo: MetaData, interfaceName: string): string {
+  const base = interfaceName.endsWith("Recovered")
+    ? interfaceName.slice(0, -"Recovered".length)
+    : interfaceName;
+  const lines: string[] = [];
+  lines.push(
+    `/** Best-effort recovered twin of \`${base}\` — every field nullable (null where lost/malformed). */`,
+  );
+  lines.push(`export interface ${interfaceName} {`);
+  for (const f of fields(vo)) {
+    lines.push(`  ${f.name}: ${mirrorType(f)};`);
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+
+/** Emit `{ prop: asString(d, "prop"), … }` building the mirror from the forgiving map `d`. */
+export function mirrorInitializer(vo: MetaData): string {
+  const assigns = fields(vo).map((f) => `${f.name}: ${recoverMapCall(f)}`);
+  return `{ ${assigns.join(", ")} }`;
+}