@workos/oagen-emitters 0.2.1 → 0.4.0

package/src/go/type-map.ts

@@ -0,0 +1,82 @@
+import type { TypeRef, PrimitiveType, UnionType } from '@workos/oagen';
+import { mapTypeRef as irMapTypeRef } from '@workos/oagen';
+import { className } from './naming.js';
+
+/**
+ * Map an IR TypeRef to a Go type string.
+ */
+export function mapTypeRef(ref: TypeRef, asPointer = false): string {
+  const base = irMapTypeRef<string>(ref, {
+    primitive: mapPrimitive,
+    array: (_ref, items) => `[]${items}`,
+    model: (r) => `*${className(r.name)}`,
+    enum: (r) => className(r.name),
+    union: (_r, variants) => joinUnionVariants(_r, variants),
+    nullable: (_ref, inner) => {
+      // If inner is already a pointer type (model), don't double-pointer
+      if (inner.startsWith('*')) return inner;
+      return `*${inner}`;
+    },
+    literal: (r) => {
+      if (r.value === null) return 'interface{}';
+      if (typeof r.value === 'string') return 'string';
+      if (typeof r.value === 'number') return Number.isInteger(r.value) ? 'int' : 'float64';
+      if (typeof r.value === 'boolean') return 'bool';
+      return 'interface{}';
+    },
+    map: (_ref, value) => `map[string]${value}`,
+  });
+  if (asPointer && !base.startsWith('*') && !base.startsWith('[]') && !base.startsWith('map[')) {
+    return `*${base}`;
+  }
+  return base;
+}
+
+/**
+ * Map an IR TypeRef to a Go type string without pointer wrapping for models.
+ * Used for response type references where we don't want a double pointer.
+ */
+export function mapTypeRefValue(ref: TypeRef): string {
+  return irMapTypeRef<string>(ref, {
+    primitive: mapPrimitive,
+    array: (_ref, items) => `[]${items}`,
+    model: (r) => className(r.name),
+    enum: (r) => className(r.name),
+    union: (_r, variants) => joinUnionVariants(_r, variants),
+    nullable: (_ref, inner) => `*${inner}`,
+    literal: (r) => {
+      if (r.value === null) return 'interface{}';
+      if (typeof r.value === 'string') return 'string';
+      if (typeof r.value === 'number') return Number.isInteger(r.value) ? 'int' : 'float64';
+      if (typeof r.value === 'boolean') return 'bool';
+      return 'interface{}';
+    },
+    map: (_ref, value) => `map[string]${value}`,
+  });
+}
+
+function mapPrimitive(ref: PrimitiveType): string {
+  if (ref.format === 'binary') return '[]byte';
+  switch (ref.type) {
+    case 'string':
+      return 'string';
+    case 'integer':
+      return 'int';
+    case 'number':
+      return 'float64';
+    case 'boolean':
+      return 'bool';
+    case 'unknown':
+      return 'interface{}';
+  }
+}
+
+function joinUnionVariants(_ref: UnionType, variants: string[]): string {
+  if (_ref.compositionKind === 'allOf') {
+    return variants[0] ?? 'interface{}';
+  }
+  const unique = [...new Set(variants)];
+  if (unique.length === 1) return unique[0];
+  // Go doesn't have union types; use interface{}
+  return 'interface{}';
+}

package/src/go/wrappers.ts

@@ -0,0 +1,261 @@
+import type { EmitterContext, ResolvedOperation, ResolvedWrapper } from '@workos/oagen';
+import {
+  className as goClassName,
+  fieldName as goFieldName,
+  methodName as goMethodName,
+  unexportedName,
+} from './naming.js';
+import { sortPathParamsByTemplateOrder } from './resources.js';
+import { resolveWrapperParams, formatWrapperDescription, type ResolvedWrapperParam } from '../shared/wrapper-utils.js';
+import { lowerFirstForDoc, fieldDocComment } from '../shared/naming-utils.js';
+
+/**
+ * Generate Go wrapper method lines for union split operations.
+ *
+ * Each wrapper is a typed convenience method that:
+ * - Accepts only the exposed params (not the full union body)
+ * - Injects constant defaults (e.g., grant_type)
+ * - Reads inferred fields from client config (e.g., client_id)
+ * - Delegates to the HTTP client with the constructed body
+ */
+export function generateWrapperMethods(
+  serviceType: string,
+  resolvedOp: ResolvedOperation,
+  ctx: EmitterContext,
+): string[] {
+  if (!resolvedOp.wrappers || resolvedOp.wrappers.length === 0) return [];
+
+  const lines: string[] = [];
+
+  for (const wrapper of resolvedOp.wrappers) {
+    const wrapperParams = resolveWrapperParams(wrapper, ctx);
+    lines.push('');
+    emitWrapperParamsStruct(lines, wrapper, wrapperParams);
+    lines.push('');
+    emitWrapperMethod(lines, serviceType, resolvedOp, wrapper, wrapperParams);
+  }
+
+  return lines;
+}
+
+function emitWrapperParamsStruct(
+  lines: string[],
+  wrapper: ResolvedWrapper,
+  wrapperParams: ResolvedWrapperParam[],
+): void {
+  const structName = `${goMethodName(wrapper.name)}Params`;
+
+  lines.push(`// ${structName} contains the parameters for ${goMethodName(wrapper.name)}.`);
+  lines.push(`type ${structName} struct {`);
+
+  for (const { paramName, field, isOptional } of wrapperParams) {
+    const goField = goFieldName(paramName);
+    const goType = field ? resolveSimpleGoType(field.type) : 'string';
+
+    if (field?.description) {
+      const fdLines = field.description.split('\n').filter((l: string) => l.trim());
+      lines.push(`\t// ${fieldDocComment(goField, fdLines[0])}`);
+      for (let i = 1; i < fdLines.length; i++) {
+        lines.push(`\t// ${fdLines[i].trim()}`);
+      }
+    }
+    if (isOptional) {
+      const optType = goType.startsWith('*') || goType.startsWith('[]') ? goType : `*${goType}`;
+      lines.push(`\t${goField} ${optType} \`json:"${paramName},omitempty"\``);
+    } else {
+      lines.push(`\t${goField} ${goType} \`json:"${paramName}"\``);
+    }
+  }
+
+  lines.push('}');
+}
+
+function emitWrapperMethod(
+  lines: string[],
+  serviceType: string,
+  resolvedOp: ResolvedOperation,
+  wrapper: ResolvedWrapper,
+  wrapperParams: ResolvedWrapperParam[],
+): void {
+  const op = resolvedOp.operation;
+  const method = goMethodName(wrapper.name);
+  const paramsStruct = `${method}Params`;
+
+  // Return type
+  const responseType = wrapper.responseModelName ? goClassName(wrapper.responseModelName) : null;
+
+  // GoDoc
+  lines.push(`// ${method} ${formatWrapperDescription(wrapper.name)}.`);
+
+  // Signature
+  const sigParams: string[] = ['ctx context.Context'];
+
+  // Path params as positional args (sorted by template order)
+  for (const p of sortPathParamsByTemplateOrder(op)) {
+    sigParams.push(`${lowerFirstSafe(goFieldName(p.name))} ${resolveSimpleGoType(p.type)}`);
+  }
+
+  sigParams.push(`params *${paramsStruct}`);
+  sigParams.push('opts ...RequestOption');
+
+  if (responseType) {
+    lines.push(`func (s *${serviceType}) ${method}(${sigParams.join(', ')}) (*${responseType}, error) {`);
+  } else {
+    lines.push(`func (s *${serviceType}) ${method}(${sigParams.join(', ')}) error {`);
+  }
+
+  // Build body map with defaults + exposed params
+  lines.push('\tbody := map[string]interface{}{');
+
+  // Constant defaults (e.g., grant_type)
+  for (const [key, value] of Object.entries(wrapper.defaults)) {
+    lines.push(`\t\t"${key}": ${goLiteral(value)},`);
+  }
+
+  // Required exposed params
+  for (const { paramName, isOptional } of wrapperParams) {
+    if (isOptional) continue;
+    const goField = goFieldName(paramName);
+    lines.push(`\t\t"${paramName}": params.${goField},`);
+  }
+
+  lines.push('\t}');
+
+  // Inferred fields from client config
+  for (const field of wrapper.inferFromClient) {
+    const expr = clientFieldExpression(field);
+    lines.push(`\tif ${expr} != "" {`);
+    lines.push(`\t\tbody["${field}"] = ${expr}`);
+    lines.push('\t}');
+  }
+
+  // Optional exposed params
+  for (const { paramName, isOptional } of wrapperParams) {
+    if (!isOptional) continue;
+    const goField = goFieldName(paramName);
+    lines.push(`\tif params.${goField} != nil {`);
+    lines.push(`\t\tbody["${paramName}"] = *params.${goField}`);
+    lines.push('\t}');
+  }
+
+  // Build path expression
+  let pathExpr: string;
+  if (op.pathParams.length > 0) {
+    let fmtStr = op.path;
+    const fmtArgs: string[] = [];
+    for (const p of sortPathParamsByTemplateOrder(op)) {
+      fmtStr = fmtStr.replace(`{${p.name}}`, '%s');
+      fmtArgs.push(lowerFirstSafe(goFieldName(p.name)));
+    }
+    pathExpr = `fmt.Sprintf("${fmtStr}", ${fmtArgs.join(', ')})`;
+  } else {
+    pathExpr = `"${op.path}"`;
+  }
+
+  // Make the request
+  if (responseType) {
+    lines.push(`\tvar result ${responseType}`);
+    lines.push(
+      `\t_, err := s.client.request(ctx, "${op.httpMethod.toUpperCase()}", ${pathExpr}, nil, body, &result, opts)`,
+    );
+    lines.push('\tif err != nil {');
+    lines.push('\t\treturn nil, err');
+    lines.push('\t}');
+    lines.push('\treturn &result, nil');
+  } else {
+    lines.push(
+      `\t_, err := s.client.request(ctx, "${op.httpMethod.toUpperCase()}", ${pathExpr}, nil, body, nil, opts)`,
+    );
+    lines.push('\treturn err');
+  }
+
+  lines.push('}');
+}
+
+/** Convert a value to a Go literal. */
+function goLiteral(value: string | number | boolean): string {
+  if (typeof value === 'string') return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+  if (typeof value === 'boolean') return value ? 'true' : 'false';
+  return String(value);
+}
+
+/** Get the Go expression for reading a client config field. */
+function clientFieldExpression(field: string): string {
+  switch (field) {
+    case 'client_id':
+      return 's.client.clientID';
+    case 'client_secret':
+      return 's.client.apiKey';
+    default:
+      return `s.client.${lowerFirstSafe(goFieldName(field))}`;
+  }
+}
+
+/** Resolve a TypeRef to a simple Go type string. */
+function resolveSimpleGoType(ref: any): string {
+  if (ref.kind === 'primitive') {
+    switch (ref.type) {
+      case 'string':
+        return 'string';
+      case 'integer':
+        return 'int';
+      case 'number':
+        return 'float64';
+      case 'boolean':
+        return 'bool';
+      default:
+        return 'interface{}';
+    }
+  }
+  if (ref.kind === 'nullable') return `*${resolveSimpleGoType(ref.inner)}`;
+  if (ref.kind === 'array') return `[]${resolveSimpleGoType(ref.items)}`;
+  if (ref.kind === 'model') return `*${goClassName(ref.name)}`;
+  if (ref.kind === 'enum') return goClassName(ref.name);
+  if (ref.kind === 'union') {
+    // For oneOf with a single non-null variant, use that variant's type
+    const nonNull = ref.variants.filter((v: any) => v.kind !== 'literal' || v.value !== null);
+    if (nonNull.length === 1) return resolveSimpleGoType(nonNull[0]);
+    return 'interface{}';
+  }
+  return 'interface{}';
+}
+
+/** Go reserved words set. */
+const GO_RESERVED = new Set([
+  'break',
+  'case',
+  'chan',
+  'const',
+  'continue',
+  'default',
+  'defer',
+  'else',
+  'fallthrough',
+  'for',
+  'func',
+  'go',
+  'goto',
+  'if',
+  'import',
+  'interface',
+  'map',
+  'package',
+  'range',
+  'return',
+  'select',
+  'struct',
+  'switch',
+  'type',
+  'var',
+]);
+
+function lowerFirstSafe(s: string): string {
+  if (!s) return s;
+  const result = unexportedName(s);
+  if (GO_RESERVED.has(result)) return `${result}Param`;
+  return result;
+}
+
+function _lowerFirstField(s: string): string {
+  return lowerFirstForDoc(s);
+}

package/src/index.ts

@@ -1 +1,5 @@
 export { nodeEmitter } from './node/index.js';
+export { pythonEmitter } from './python/index.js';
+export { phpEmitter } from './php/index.js';
+export { goEmitter } from './go/index.js';
+export { dotnetEmitter } from './dotnet/index.js';

package/src/kotlin/client.ts

@@ -0,0 +1,53 @@
+import type { ApiSpec, EmitterContext, GeneratedFile, Service } from '@workos/oagen';
+import { apiClassName, packageSegment, servicePropertyName } from './naming.js';
+import { getMountTarget } from '../shared/resolved-ops.js';
+
+const KOTLIN_SRC_PREFIX = 'src/main/kotlin/';
+
+/**
+ * Generate service accessor properties for the hand-maintained `WorkOS` class.
+ *
+ * Each accessor is a `val` property with a custom getter that delegates to
+ * `WorkOS.service(...)` for lazy, cached construction. The generated file
+ * contains a `WorkOS` class stub with only these properties — the oagen
+ * merger deep-merges them into the existing hand-written `WorkOS.kt`.
+ *
+ * Accessors use fully-qualified type names so the merger doesn't need to
+ * inject imports into the hand-written file.
+ */
+export function generateClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
+  const targets = deduplicateByMount(spec.services, ctx);
+  if (targets.length === 0) return [];
+
+  const accessorLines: string[] = [];
+  for (const mount of targets) {
+    const apiCls = apiClassName(mount);
+    const fqn = `com.workos.${packageSegment(mount)}.${apiCls}`;
+    const prop = servicePropertyName(mount);
+    accessorLines.push('');
+    accessorLines.push(`  /** Lazily-constructed [${apiCls}] accessor for this [WorkOS] client. */`);
+    accessorLines.push(`  val ${prop}: ${fqn}`);
+    accessorLines.push(`    get() = service(${fqn}::class) { ${fqn}(this) }`);
+  }
+
+  const lines: string[] = [];
+  lines.push('package com.workos');
+  lines.push('');
+  lines.push('open class WorkOS {');
+  for (const line of accessorLines) lines.push(line);
+  lines.push('}');
+  lines.push('');
+
+  return [
+    {
+      path: `${KOTLIN_SRC_PREFIX}com/workos/WorkOS.kt`,
+      content: lines.join('\n'),
+    },
+  ];
+}
+
+function deduplicateByMount(services: Service[], ctx: EmitterContext): string[] {
+  const targets = new Set<string>();
+  for (const s of services) targets.add(getMountTarget(s, ctx));
+  return [...targets].sort();
+}

package/src/kotlin/enums.ts

@@ -0,0 +1,162 @@
+import type { Enum, EmitterContext, GeneratedFile } from '@workos/oagen';
+import { className, ktStringLiteral } from './naming.js';
+
+const KOTLIN_SRC_PREFIX = 'src/main/kotlin/';
+const ENUMS_PACKAGE = 'com.workos.types';
+const ENUMS_DIR = 'com/workos/types';
+
+/**
+ * Mapping from an IR enum name to its canonical enum name. When two enums
+ * share identical sorted wire values the shorter-named one is canonical and
+ * the others become `typealias` files. Downstream consumers (type-map,
+ * resources) use this map to resolve references to the canonical class.
+ */
+export const enumCanonicalMap = new Map<string, string>();
+
+/**
+ * Generate Kotlin `enum class` types from the IR enums. Each enum is emitted
+ * to its own file under `com.workos.types`, annotated with Jackson
+ * `@JsonValue` on the wire value. An `Unknown` sentinel is always the first
+ * constant so that responses with new variants still deserialize instead of
+ * throwing.
+ *
+ * Enums with identical sets of wire values are deduplicated: the one with the
+ * shortest PascalCase name becomes canonical and the rest emit `typealias`
+ * files pointing at the canonical class.
+ */
+export function generateEnums(enums: Enum[], _ctx: EmitterContext): GeneratedFile[] {
+  if (enums.length === 0) return [];
+
+  // Reset the canonical map on every generation run (guards against re-entry).
+  enumCanonicalMap.clear();
+
+  // --- Dedup: group enums by a hash of their sorted wire values. ---
+  const hashGroups = new Map<string, Enum[]>();
+  for (const enumDef of enums) {
+    if (enumDef.values.length === 0) continue;
+    const hash = enumWireHash(enumDef);
+    if (!hashGroups.has(hash)) hashGroups.set(hash, []);
+    hashGroups.get(hash)!.push(enumDef);
+  }
+
+  // Within each group, pick the shortest className as canonical.
+  const aliasOf = new Map<string, string>(); // enum name → canonical enum name
+  for (const [, group] of hashGroups) {
+    if (group.length <= 1) continue;
+    const sorted = [...group].sort(
+      (a, b) =>
+        className(a.name).length - className(b.name).length || className(a.name).localeCompare(className(b.name)),
+    );
+    const canonical = sorted[0];
+    for (let i = 1; i < sorted.length; i++) {
+      aliasOf.set(sorted[i].name, canonical.name);
+      enumCanonicalMap.set(sorted[i].name, canonical.name);
+    }
+  }
+
+  const files: GeneratedFile[] = [];
+
+  for (const enumDef of enums) {
+    if (enumDef.values.length === 0) continue;
+
+    const typeName = className(enumDef.name);
+
+    // Non-canonical enum: emit a typealias instead of a full enum class.
+    const canonicalName = aliasOf.get(enumDef.name);
+    if (canonicalName) {
+      const canonicalType = className(canonicalName);
+      const aliasLine = `typealias ${typeName} = ${canonicalType}`;
+      // ktlint enforces a 140-char max line length. When the typealias
+      // exceeds that, add a @file:Suppress to avoid an unfixable violation.
+      const suppressLine = aliasLine.length > 140 ? `@file:Suppress("ktlint:standard:max-line-length")\n\n` : '';
+      const aliasContent = [`${suppressLine}package ${ENUMS_PACKAGE}`, '', aliasLine, ''].join('\n');
+      files.push({
+        path: `${KOTLIN_SRC_PREFIX}${ENUMS_DIR}/${typeName}.kt`,
+        content: aliasContent,
+        overwriteExisting: true,
+      });
+      continue;
+    }
+
+    const lines: string[] = [];
+    lines.push(`package ${ENUMS_PACKAGE}`);
+    lines.push('');
+    lines.push('import com.fasterxml.jackson.annotation.JsonEnumDefaultValue');
+    lines.push('import com.fasterxml.jackson.annotation.JsonValue');
+    lines.push('');
+    // Replace the tautological "Foo enum." docstring with a slightly more
+    // informative summary. `Unknown` is emitted as the forward-compatibility
+    // sentinel for values the server introduces after this SDK was built.
+    lines.push(`/** Enumeration of valid ${typeName} values returned or accepted by the API. */`);
+    lines.push(`enum class ${typeName}(`);
+    lines.push('  @JsonValue val value: String');
+    lines.push(') {');
+    // `@JsonEnumDefaultValue` makes Jackson's
+    // READ_UNKNOWN_ENUM_VALUES_USING_DEFAULT_VALUE feature map unrecognized
+    // wire values onto `Unknown` instead of throwing — required for forward
+    // compatibility when the API introduces new variants.
+    lines.push('  @JsonEnumDefaultValue');
+    lines.push(`  Unknown(${ktStringLiteral('unknown')}),`);
+
+    const seenNames = new Set<string>(['Unknown']);
+    const seenWire = new Set<string>(['unknown']);
+    const members: string[] = [];
+
+    for (const v of enumDef.values) {
+      const wire = String(v.value);
+      if (seenWire.has(wire)) continue;
+      seenWire.add(wire);
+
+      let memberName = className(wire);
+      if (!memberName || /^[0-9]/.test(memberName)) memberName = `Value${memberName || wire}`;
+      if (memberName === typeName || seenNames.has(memberName)) {
+        let suffix = 2;
+        while (seenNames.has(`${memberName}${suffix}`)) suffix += 1;
+        memberName = `${memberName}${suffix}`;
+      }
+      seenNames.add(memberName);
+
+      if (v.description?.trim()) {
+        members.push(`  /** ${escapeKdoc(v.description.split('\n')[0].trim())} */`);
+      }
+      if (v.deprecated) {
+        members.push('  @Deprecated("Deprecated enum value")');
+      }
+      members.push(`  ${memberName}(${ktStringLiteral(wire)})`);
+    }
+
+    for (let i = 0; i < members.length; i++) {
+      const isLast = i === members.length - 1;
+      const line = members[i];
+      const trimmedStart = line.trimStart();
+      if (trimmedStart.startsWith('/**') || trimmedStart.startsWith('@')) {
+        lines.push(line);
+        continue;
+      }
+      lines.push(isLast ? line : `${line},`);
+    }
+
+    lines.push('}');
+    lines.push('');
+
+    files.push({
+      path: `${KOTLIN_SRC_PREFIX}${ENUMS_DIR}/${typeName}.kt`,
+      content: lines.join('\n'),
+      overwriteExisting: true,
+    });
+  }
+
+  return files;
+}
+
+/** Hash an enum by its sorted wire values so identical enums collide. */
+function enumWireHash(enumDef: Enum): string {
+  return [...enumDef.values]
+    .map((v) => String(v.value))
+    .sort()
+    .join('|');
+}
+
+function escapeKdoc(s: string): string {
+  return s.replace(/\*\//g, '*\u200b/');
+}

package/src/kotlin/index.ts

@@ -0,0 +1,92 @@
+import type {
+  Emitter,
+  EmitterContext,
+  FormatCommand,
+  GeneratedFile,
+  ApiSpec,
+  Model,
+  Enum,
+  Service,
+} from '@workos/oagen';
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { generateModels } from './models.js';
+import { generateEnums } from './enums.js';
+import { generateResources } from './resources.js';
+import { generateClient } from './client.js';
+import { generateTests } from './tests.js';
+import { generateManifest } from './manifest.js';
+import { enrichModelsFromSpec, getSyntheticEnums } from '../shared/model-utils.js';
+
+/** Ensure every generated file ends with a trailing newline. */
+function ensureTrailingNewlines(files: GeneratedFile[]): GeneratedFile[] {
+  for (const f of files) {
+    if (f.content && !f.content.endsWith('\n')) {
+      f.content += '\n';
+    }
+  }
+  return files;
+}
+
+export const kotlinEmitter: Emitter = {
+  language: 'kotlin',
+
+  generateModels(models: Model[], ctx: EmitterContext): GeneratedFile[] {
+    const enriched = enrichModelsFromSpec(models);
+    return ensureTrailingNewlines(generateModels(enriched, ctx));
+  },
+
+  generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile[] {
+    // Merge synthetic enums produced during model enrichment (inline oneOf
+    // definitions) so they get proper enum class files.
+    const syntheticEnums = getSyntheticEnums();
+    return ensureTrailingNewlines(generateEnums([...enums, ...syntheticEnums], ctx));
+  },
+
+  generateResources(services: Service[], ctx: EmitterContext): GeneratedFile[] {
+    return ensureTrailingNewlines(generateResources(services, ctx));
+  },
+
+  generateClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
+    return ensureTrailingNewlines(generateClient(spec, ctx));
+  },
+
+  generateErrors(_ctx: EmitterContext): GeneratedFile[] {
+    // Exception hierarchy is hand-maintained in workos-kotlin (see Phase 2).
+    return [];
+  },
+
+  generateTypeSignatures(): GeneratedFile[] {
+    return [];
+  },
+
+  generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
+    // Pass enriched models so round-trip tests see the full field set
+    // (including optional oneOf-enriched fields) and can filter accurately.
+    const enrichedModels = enrichModelsFromSpec(spec.models);
+    const enrichedSpec: ApiSpec = { ...spec, models: enrichedModels };
+    return ensureTrailingNewlines(generateTests(enrichedSpec, { ...ctx, spec: enrichedSpec }));
+  },
+
+  generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
+    return ensureTrailingNewlines(generateManifest(spec, ctx));
+  },
+
+  fileHeader(): string {
+    return '// This file is auto-generated by oagen. Do not edit.';
+  },
+
+  formatCommand(targetDir: string): FormatCommand | null {
+    // ktlint enforces a 140-char max line length that cannot be auto-corrected
+    // by the Gradle plugin alone, but `./gradlew ktlintFormat` fixes most
+    // violations (trailing whitespace, import ordering, etc.) across all
+    // generated files. The file list appended by oagen is ignored — Gradle
+    // reformats the whole source set.
+    if (!fs.existsSync(path.join(targetDir, 'gradlew'))) return null;
+    return {
+      cmd: 'bash',
+      args: ['-c', `cd ${JSON.stringify(targetDir)} && ./gradlew ktlintFormat --quiet 2>/dev/null; true`, '--'],
+    };
+  },
+};