feat(openai-codegen): Wave 1 — AST nodes, OAS loader, target profiles

- abap-ast: typed node interfaces + factories for classes, interfaces, types,
  methods, statements, expressions, data declarations (59 unit tests).
- openai-codegen: OAS loader (swagger-parser + yaml) + normalizer that merges
  path-level parameters, synthesises missing operationIds, classifies 2xx/4xx/5xx
  responses, and preserves named components.schemas before dereferencing
  (11 tests, exercised against vendored Petstore v3 fixture).
- openai-codegen: target profile registry with full s4-cloud definition
  (web HTTP client + inline JSON) and stubs for on-prem profiles; class
  whitelist enforcement with WhitelistViolationError (5 tests).

All four verification targets (typecheck, test, build, lint) pass on both
packages.

Generated with [Devin](https://cli.devin.ai/docs)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>

Author: ThePlenkov

packages/abap-ast/src/nodes/base.ts

@@ -0,0 +1,83 @@
+import { AbapAstError } from './errors';
+
+/** All node kinds in the AST. */
+export type NodeKind =
+  // types
+  | 'BuiltinType'
+  | 'TableType'
+  | 'StructureType'
+  | 'NamedTypeRef'
+  | 'EnumType'
+  | 'TypeDef'
+  // data
+  | 'DataDecl'
+  | 'ConstantDecl'
+  | 'FieldSymbolDecl'
+  // statements
+  | 'Assign'
+  | 'Call'
+  | 'Raise'
+  | 'If'
+  | 'Loop'
+  | 'Return'
+  | 'Try'
+  | 'Append'
+  | 'Insert'
+  | 'Read'
+  | 'Clear'
+  | 'Exit'
+  | 'Continue'
+  | 'Raw'
+  // expressions
+  | 'Literal'
+  | 'IdentifierExpr'
+  | 'ConstructorExpr'
+  | 'MethodCallExpr'
+  | 'BinOp'
+  | 'StringTemplate'
+  | 'Cast'
+  // members
+  | 'MethodParam'
+  | 'MethodDef'
+  | 'MethodImpl'
+  | 'EventDef'
+  | 'AttributeDef'
+  // class / interface
+  | 'Section'
+  | 'ClassDef'
+  | 'LocalClassDef'
+  | 'InterfaceDef'
+  // shared
+  | 'Comment';
+
+/** Base shape for any AST node. */
+export interface AbapNode {
+  readonly kind: NodeKind;
+}
+
+/** An ABAP identifier (not validated beyond presence). */
+export type Identifier = string;
+
+/** An ABAP comment. Star comments begin at column 1; line comments use `"`. */
+export interface Comment extends AbapNode {
+  readonly kind: 'Comment';
+  readonly text: string;
+  readonly style: 'star' | 'line';
+}
+
+export function comment(input: {
+  text: string;
+  style?: 'star' | 'line';
+}): Comment {
+  if (typeof input.text !== 'string') {
+    throw new AbapAstError('Comment: required field "text" is missing');
+  }
+  return Object.freeze({
+    kind: 'Comment' as const,
+    text: input.text,
+    style: input.style ?? 'line',
+  });
+}
+
+/** Visibility modifier for class members / sections. */
+export type Visibility = 'public' | 'protected' | 'private';

packages/abap-ast/src/nodes/class.ts

@@ -0,0 +1,133 @@
+import type { AbapNode, Identifier, Visibility } from './base';
+import { AbapAstError } from './errors';
+import type { TypeDef } from './types';
+import type { ConstantDecl } from './data';
+import type { AttributeDef, EventDef, MethodDef, MethodImpl } from './members';
+
+/** A member that may appear inside a class section. */
+export type SectionMember =
+  | TypeDef
+  | AttributeDef
+  | MethodDef
+  | ConstantDecl
+  | EventDef;
+
+/** A visibility section of a class definition. */
+export interface Section extends AbapNode {
+  readonly kind: 'Section';
+  readonly visibility: Visibility;
+  readonly members: readonly SectionMember[];
+}
+
+export function section(input: {
+  visibility: Visibility;
+  members?: readonly SectionMember[];
+}): Section {
+  if (!input.visibility) {
+    throw new AbapAstError('Section: required field "visibility" is missing');
+  }
+  const members = input.members ?? [];
+  for (const m of members) {
+    if ('visibility' in m && m.visibility !== input.visibility) {
+      throw new AbapAstError(
+        `Section: member "${m.name}" has visibility "${m.visibility}" but section is "${input.visibility}"`,
+      );
+    }
+  }
+  return Object.freeze({
+    kind: 'Section' as const,
+    visibility: input.visibility,
+    members: Object.freeze([...members]),
+  });
+}
+
+/** Top-level global class (`CLASS ... DEFINITION` + `IMPLEMENTATION`). */
+export interface ClassDef extends AbapNode {
+  readonly kind: 'ClassDef';
+  readonly name: Identifier;
+  readonly superclass?: Identifier;
+  readonly interfaces: readonly Identifier[];
+  readonly isFinal?: boolean;
+  readonly isAbstract?: boolean;
+  readonly isForTesting?: boolean;
+  readonly isCreatePrivate?: boolean;
+  readonly sections: readonly Section[];
+  readonly implementations: readonly MethodImpl[];
+}
+
+export function classDef(input: {
+  name: Identifier;
+  superclass?: Identifier;
+  interfaces?: readonly Identifier[];
+  isFinal?: boolean;
+  isAbstract?: boolean;
+  isForTesting?: boolean;
+  isCreatePrivate?: boolean;
+  sections?: readonly Section[];
+  implementations?: readonly MethodImpl[];
+}): ClassDef {
+  if (!input.name) {
+    throw new AbapAstError('ClassDef: required field "name" is missing');
+  }
+  if (input.isFinal && input.isAbstract) {
+    throw new AbapAstError('ClassDef: class cannot be both FINAL and ABSTRACT');
+  }
+  return Object.freeze({
+    kind: 'ClassDef' as const,
+    name: input.name,
+    superclass: input.superclass,
+    interfaces: Object.freeze([...(input.interfaces ?? [])]),
+    isFinal: input.isFinal,
+    isAbstract: input.isAbstract,
+    isForTesting: input.isForTesting,
+    isCreatePrivate: input.isCreatePrivate,
+    sections: Object.freeze([...(input.sections ?? [])]),
+    implementations: Object.freeze([...(input.implementations ?? [])]),
+  });
+}
+
+/** A local class inside a CLAS-POOL (same shape as ClassDef, flagged local). */
+export interface LocalClassDef extends AbapNode {
+  readonly kind: 'LocalClassDef';
+  readonly name: Identifier;
+  readonly superclass?: Identifier;
+  readonly interfaces: readonly Identifier[];
+  readonly isFinal?: boolean;
+  readonly isAbstract?: boolean;
+  readonly isForTesting?: boolean;
+  readonly sections: readonly Section[];
+  readonly implementations: readonly MethodImpl[];
+  readonly local: true;
+}
+
+export function localClassDef(input: {
+  name: Identifier;
+  superclass?: Identifier;
+  interfaces?: readonly Identifier[];
+  isFinal?: boolean;
+  isAbstract?: boolean;
+  isForTesting?: boolean;
+  sections?: readonly Section[];
+  implementations?: readonly MethodImpl[];
+}): LocalClassDef {
+  if (!input.name) {
+    throw new AbapAstError('LocalClassDef: required field "name" is missing');
+  }
+  if (input.isFinal && input.isAbstract) {
+    throw new AbapAstError(
+      'LocalClassDef: class cannot be both FINAL and ABSTRACT',
+    );
+  }
+  return Object.freeze({
+    kind: 'LocalClassDef' as const,
+    name: input.name,
+    superclass: input.superclass,
+    interfaces: Object.freeze([...(input.interfaces ?? [])]),
+    isFinal: input.isFinal,
+    isAbstract: input.isAbstract,
+    isForTesting: input.isForTesting,
+    sections: Object.freeze([...(input.sections ?? [])]),
+    implementations: Object.freeze([...(input.implementations ?? [])]),
+    local: true as const,
+  });
+}

packages/abap-ast/src/nodes/data.ts

@@ -0,0 +1,96 @@
+import type { AbapNode, Identifier } from './base';
+import { AbapAstError } from './errors';
+import type { TypeRef } from './types';
+import type { Expression } from './expressions';
+
+/** `DATA lv_x TYPE ... [VALUE ...]`. */
+export interface DataDecl extends AbapNode {
+  readonly kind: 'DataDecl';
+  readonly name: Identifier;
+  readonly type: TypeRef;
+  readonly initial?: Expression;
+  readonly classData?: boolean;
+}
+
+export function dataDecl(input: {
+  name: Identifier;
+  type: TypeRef;
+  initial?: Expression;
+  classData?: boolean;
+}): DataDecl {
+  if (!input.name) {
+    throw new AbapAstError('DataDecl: required field "name" is missing');
+  }
+  if (!input.type) {
+    throw new AbapAstError('DataDecl: required field "type" is missing');
+  }
+  return Object.freeze({
+    kind: 'DataDecl' as const,
+    name: input.name,
+    type: input.type,
+    initial: input.initial,
+    classData: input.classData,
+  });
+}
+
+/** `CONSTANTS c_x TYPE ... VALUE ...`. */
+export interface ConstantDecl extends AbapNode {
+  readonly kind: 'ConstantDecl';
+  readonly name: Identifier;
+  readonly type: TypeRef;
+  readonly value: Expression;
+  readonly classData?: boolean;
+}
+
+export function constantDecl(input: {
+  name: Identifier;
+  type: TypeRef;
+  value: Expression;
+  classData?: boolean;
+}): ConstantDecl {
+  if (!input.name) {
+    throw new AbapAstError('ConstantDecl: required field "name" is missing');
+  }
+  if (!input.type) {
+    throw new AbapAstError('ConstantDecl: required field "type" is missing');
+  }
+  if (!input.value) {
+    throw new AbapAstError('ConstantDecl: required field "value" is missing');
+  }
+  return Object.freeze({
+    kind: 'ConstantDecl' as const,
+    name: input.name,
+    type: input.type,
+    value: input.value,
+    classData: input.classData,
+  });
+}
+
+/** `FIELD-SYMBOLS <fs_x> TYPE ...`. */
+export interface FieldSymbolDecl extends AbapNode {
+  readonly kind: 'FieldSymbolDecl';
+  readonly name: Identifier;
+  readonly type: TypeRef;
+}
+
+export function fieldSymbolDecl(input: {
+  name: Identifier;
+  type: TypeRef;
+}): FieldSymbolDecl {
+  if (!input.name) {
+    throw new AbapAstError('FieldSymbolDecl: required field "name" is missing');
+  }
+  if (!input.name.startsWith('<') || !input.name.endsWith('>')) {
+    throw new AbapAstError(
+      `FieldSymbolDecl: name "${input.name}" must be wrapped in angle brackets (e.g. <fs_x>)`,
+    );
+  }
+  if (!input.type) {
+    throw new AbapAstError('FieldSymbolDecl: required field "type" is missing');
+  }
+  return Object.freeze({
+    kind: 'FieldSymbolDecl' as const,
+    name: input.name,
+    type: input.type,
+  });
+}

packages/abap-ast/src/nodes/errors.ts

@@ -0,0 +1,17 @@
+export class AbapAstError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'AbapAstError';
+  }
+}
+
+export function requireField<T>(
+  value: T | undefined | null,
+  field: string,
+  nodeKind: string,
+): T {
+  if (value === undefined || value === null || value === '') {
+    throw new AbapAstError(`${nodeKind}: required field "${field}" is missing`);
+  }
+  return value;
+}