@autobe/agent 0.20.0 → 0.22.0

package/src/orchestrate/realize/structures/IAutoBeRealizeWriteApplication.ts

@@ -1,11 +1,35 @@
 export interface IAutoBeRealizeWriteApplication {
+  /**
+   * Generates provider function implementation through multi-phase development.
+   *
+   * This method implements a systematic approach to generate NestJS provider
+   * functions that handle business logic for API operations. It follows a
+   * schema-first approach with multiple refinement phases to ensure type-safe,
+   * error-free code generation.
+   *
+   * The generation process includes:
+   * 1. Strategic planning based on Prisma schema analysis
+   * 2. Initial draft without Date type usage
+   * 3. Review and refinement for completeness
+   * 4. Compiler feedback integration if errors detected
+   * 5. Final implementation with all validations and type safety
+   *
+   * @param next Properties containing the multi-phase implementation plan and code
+   */
   coding: (next: IAutoBeRealizeWriteApplication.IProps) => void;
 }
 
 export namespace IAutoBeRealizeWriteApplication {
+  /**
+   * Properties for the Realize Write Application following Chain of Thinking (CoT).
+   * 
+   * Each field represents a distinct phase in the reasoning and implementation process,
+   * building upon the previous step to create a complete, error-free implementation.
+   * This structured approach ensures clarity, debuggability, and systematic thinking.
+   */
   export interface IProps {
     /**
-     * Step 1.
+     * Step 1 - Planning Phase (CoT: Initial Reasoning)
      *
      * 🧠 Provider Function Implementation Plan
      *
@@ -18,13 +42,18 @@ export namespace IAutoBeRealizeWriteApplication {
      * 📋 STEP 1 - PRISMA SCHEMA VERIFICATION:
      *
      * DO:
+     *
      * - Examine the actual Prisma schema model definition
      * - List EVERY field that exists in the model with exact types
      * - Explicitly note fields that DO NOT exist
-     * 
+     * - Verify database compatibility (PostgreSQL AND SQLite)
+     *
      * DO NOT:
+     *
      * - Assume common fields exist without verification
-     * - Use fields like deleted_at, created_by, updated_by, is_deleted, is_active without checking
+     * - Use fields like deleted_at, created_by, updated_by, is_deleted, is_active
+     *   without checking
+     * - Use PostgreSQL-specific features like mode: "insensitive"
      *
      * 📋 STEP 2 - FIELD INVENTORY:
      *
@@ -133,7 +162,7 @@ export namespace IAutoBeRealizeWriteApplication {
     plan: string;
 
     /**
-     * Step 2.
+     * Step 2 - Schema Definition (CoT: Context Establishment)
      *
      * The Prisma schema string that will be used to validate the implementation
      * logic in this file.
@@ -155,13 +184,13 @@ export namespace IAutoBeRealizeWriteApplication {
     prisma_schemas: string;
 
     /**
-     * Step 3.
+     * Step 3 - Initial Draft (CoT: First Implementation Attempt)
      *
      * Draft WITHOUT using native Date type.
      *
      * This is the initial drafting phase where you outline the basic skeleton
      * of the function.
-     * 
+     *
      * DO NOT: Use the native Date type.
      *
      * - The function signature must correctly include `user`, `parameters`, and
@@ -174,10 +203,12 @@ export namespace IAutoBeRealizeWriteApplication {
      * Import rules:
      *
      * DO NOT:
+     *
      * - Add any new import statements manually
      * - Write import statements directly (this causes compile errors)
-     * 
-     * Note: All necessary imports are provided globally or by the system automatically.
+     *
+     * Note: All necessary imports are provided globally or by the system
+     * automatically.
      *
      * ✅ Requirements:
      *
@@ -190,7 +221,7 @@ export namespace IAutoBeRealizeWriteApplication {
     draft_without_date_type: string;
 
     /**
-     * Step 4.
+     * Step 4 - Review and Refinement (CoT: Self-Reflection)
      *
      * A refined version of the draft with improved completeness.
      *
@@ -204,29 +235,13 @@ export namespace IAutoBeRealizeWriteApplication {
      * - Avoid unsafe `as` casts unless only for branding or literal narrowing.
      * - Use `toISOStringSafe()` for all date conversions (NOT `.toISOString()`).
      * - Ensure all object keys strictly conform to the expected type definitions.
+     * - NEVER use `mode: "insensitive"` in string operations (breaks SQLite).
      */
     review: string;
 
-    /**
-     * 🛠 Phase 4-2: With compiler feedback (optional)
-     *
-     * A correction pass that applies fixes for compile-time errors that arose
-     * during the review stage (if any).
-     *
-     * ✅ Must:
-     *
-     * - Only include this field if TypeScript errors are detected in the Review
-     *   phase.
-     * - Resolve all TypeScript errors without using `as any`.
-     * - Provide safe brand casting only if required (e.g., `as string &
-     *   tags.Format<'uuid'>`).
-     * - If no TypeScript errors exist, this field MUST contain the text: "No
-     *   TypeScript errors detected - skipping this phase"
-     */
-    withCompilerFeedback: string;
 
     /**
-     * Step 5.
+     * Step 5 - Complete Implementation (CoT: Final Synthesis)
      *
      * The complete and fully correct TypeScript function implementation.
      *
@@ -238,6 +253,7 @@ export namespace IAutoBeRealizeWriteApplication {
      * - Uses only allowed imports (e.g., from `../api/structures` and
      *   `MyGlobal.prisma`).
      * - NEVER creates intermediate variables for Prisma operations.
+     * - NEVER uses `mode: "insensitive"` (PostgreSQL-only, breaks SQLite).
      *
      * ⚠️ Fallback Behavior:
      *

package/src/orchestrate/realize/utils/getRealizeWriteCodeTemplate.ts

@@ -0,0 +1,97 @@
+import { AutoBeOpenApi, AutoBeRealizeAuthorization } from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+
+import { IAutoBeRealizeScenarioResult } from "../structures/IAutoBeRealizeScenarioResult";
+import { getRealizeWriteImportStatements } from "./getRealizeWriteImportStatements";
+
+/**
+ * Generate a TypeScript function template for the Realize Agent to complete
+ *
+ * This utility creates a function skeleton with proper imports, parameters, and
+ * return type that the AI needs to implement. The template includes:
+ *
+ * - Import statements for required dependencies
+ * - Function signature with all parameters
+ * - Return type specification
+ *
+ * @example
+ *   // Returns a template like:
+ *   ```typescript
+ *   import { MyGlobal } from "../MyGlobal";
+ *   // ... other imports
+ *
+ *   async function post__users_create(
+ *     body: IUserCreateRequest
+ *   ): Promise<IUserResponse> {
+ *     ...
+ *   }
+ *   ```;
+ *
+ * @param scenario - The realize scenario containing function metadata
+ * @param operation - OpenAPI operation definition
+ * @param authorization - Authorization context if endpoint is authenticated
+ * @returns Complete TypeScript code template as a formatted string
+ */
+export function getRealizeWriteCodeTemplate(
+  scenario: IAutoBeRealizeScenarioResult,
+  operation: AutoBeOpenApi.IOperation,
+  authorization: AutoBeRealizeAuthorization | null,
+): string {
+  // Collect all function parameters in order
+  const functionParameters: string[] = [];
+
+  // Add authentication parameter if needed (e.g., user: IUser, admin: IAdmin)
+  if (authorization && authorization.role.name) {
+    // Debug: Log the values to check what's being used
+    const authParameter = `${authorization.role.name}: ${authorization.payload.name}`;
+    functionParameters.push(authParameter);
+  }
+
+  // Add path parameters (e.g., id, postId, etc.)
+  const pathParameters = operation.parameters.map((param) => {
+    const paramType = param.schema.type;
+    const paramFormat =
+      "format" in param.schema
+        ? ` & tags.Format<'${param.schema.format}'>`
+        : "";
+    return `${param.name}: ${paramType}${paramFormat}`;
+  });
+  functionParameters.push(...pathParameters);
+
+  // Add request body parameter if present
+  if (operation.requestBody?.typeName) {
+    const bodyParameter = `body: ${operation.requestBody.typeName}`;
+    functionParameters.push(bodyParameter);
+  }
+
+  // Format parameters for props object
+  const hasParameters = functionParameters.length > 0;
+
+  let formattedSignature: string;
+  if (hasParameters) {
+    const propsFields = functionParameters
+      .map((param) => `  ${param}`)
+      .join(";\n");
+
+    formattedSignature = `props: {\n${propsFields};\n}`;
+  } else {
+    formattedSignature = "";
+  }
+
+  // Determine return type
+  const returnType = operation.responseBody?.typeName ?? "void";
+
+  // Generate the complete template
+  return StringUtil.trim`
+    Complete the code below, disregard the import part and return only the function part.
+
+    \`\`\`typescript
+    ${getRealizeWriteImportStatements(operation).join("\n")} 
+
+    // ONLY YOU HAVE TO WRITE THIS, AND USE IMPORTED.
+    export async function ${scenario.functionName}(${formattedSignature}): Promise<${returnType}> {
+      ...
+    }
+    \`\`\`
+  `;
+}

package/src/orchestrate/realize/utils/getRealizeWriteDto.ts

@@ -0,0 +1,64 @@
+import { AutoBeOpenApi, IAutoBeCompiler } from "@autobe/interface";
+import { ILlmSchema, OpenApiTypeChecker } from "@samchon/openapi";
+
+import { AutoBeContext } from "../../../context/AutoBeContext";
+
+export async function getRealizeWriteDto<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  operation: AutoBeOpenApi.IOperation,
+): Promise<Record<string, string>> {
+  const document: AutoBeOpenApi.IDocument = filterDocument(
+    operation,
+    ctx.state().interface!.document,
+  );
+
+  const compiler: IAutoBeCompiler = await ctx.compiler();
+  const entries: [string, string][] = Object.entries(
+    await compiler.interface.write(document),
+  );
+
+  const filter = (prefix: string, exclude?: string) => {
+    const result: [string, string][] = entries.filter(
+      ([key]) => key.startsWith(prefix) === true,
+    );
+    return Object.fromEntries(
+      exclude
+        ? result.filter(([key]) => key.startsWith(exclude) === false)
+        : result,
+    );
+  };
+
+  const dto: Record<string, string> = filter("src/api/structures");
+  return dto;
+}
+
+function filterDocument(
+  operation: AutoBeOpenApi.IOperation,
+  document: AutoBeOpenApi.IDocument,
+): AutoBeOpenApi.IDocument {
+  const components: AutoBeOpenApi.IComponents = {
+    authorization: document.components.authorization,
+    schemas: {},
+  };
+
+  const visit = (typeName: string) => {
+    OpenApiTypeChecker.visit({
+      components: document.components,
+      schema: { $ref: `#/components/schemas/${typeName}` },
+      closure: (s) => {
+        if (OpenApiTypeChecker.isReference(s)) {
+          const key: string = s.$ref.split("/").pop()!;
+          components.schemas[key] = document.components.schemas[key];
+        }
+      },
+    });
+  };
+
+  if (operation.requestBody) visit(operation.requestBody.typeName);
+  if (operation.responseBody) visit(operation.responseBody.typeName);
+
+  return {
+    operations: [operation],
+    components,
+  };
+}

package/src/orchestrate/realize/utils/getRealizeWriteImportStatements.ts

@@ -0,0 +1,29 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+
+export function getRealizeWriteImportStatements(
+  operation: AutoBeOpenApi.IOperation,
+) {
+  const typeReferences: string[] = Array.from(
+    new Set(
+      [operation.requestBody, operation.responseBody]
+        .filter((el) => el !== null)
+        .map((el) => el.typeName.split(".")[0]!),
+    ),
+  );
+
+  // Build the standard imports
+  const imports = [
+    'import jwt from "jsonwebtoken";',
+    'import { MyGlobal } from "../MyGlobal";',
+    'import typia, { tags } from "typia";',
+    'import { Prisma } from "@prisma/client";',
+    'import { v4 } from "uuid";',
+    'import { toISOStringSafe } from "../util/toISOStringSafe"',
+    ...typeReferences.map(
+      (ref) =>
+        `import { ${ref} } from "@ORGANIZATION/PROJECT-api/lib/structures/${ref}";`,
+    ),
+  ];
+
+  return imports;
+}

package/src/orchestrate/realize/utils/getRealizeWriteInputType.ts

@@ -0,0 +1,82 @@
+import { AutoBeOpenApi, AutoBeRealizeAuthorization } from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+
+/**
+ * Generate TypeScript type definition string for provider function props
+ *
+ * This utility creates the exact props interface that the Realize Agent's
+ * generated provider functions must accept. It combines:
+ *
+ * - Authentication context (user/admin/member from authorization)
+ * - URL path parameters (e.g., id, boardId, postId)
+ * - Request body type (if applicable)
+ *
+ * The output is injected into REALIZE_WRITE_ARTIFACT.md template to tell the AI
+ * exactly what parameter type the function should accept.
+ *
+ * @example
+ *   // For DELETE /posts/:id (authenticated)
+ *   // Returns: "props: { user: IUser; id: string & tags.Format<'uuid'>; }"
+ *
+ * @example
+ *   // For GET /public/info (no auth, no params)
+ *   // Returns: "// No props parameter needed - function should have no parameters"
+ *
+ * @param operation - OpenAPI operation definition containing parameters and
+ *   auth requirements
+ * @param authorization - Authorization context with user/role information (if
+ *   authenticated endpoint)
+ * @returns TypeScript interface string like "props: { user: IUser; id: string;
+ *   body: IRequest; }"
+ */
+export function getRealizeWriteInputType(
+  operation: AutoBeOpenApi.IOperation,
+  authorization: AutoBeRealizeAuthorization | null,
+): string {
+  const functionParameterFields: string[] = [];
+
+  // Add authentication field (user/admin/member) if endpoint requires auth
+  const hasAuthentication = authorization && operation.authorizationRole;
+  if (hasAuthentication) {
+    const authFieldName = operation.authorizationRole;
+    const authFieldType = authorization.payload.name;
+    functionParameterFields.push(`${authFieldName}: ${authFieldType};`);
+  }
+
+  // Add URL path parameters (e.g., /posts/:id → id parameter)
+  const pathParameters = operation.parameters;
+  pathParameters.forEach((pathParam) => {
+    const paramName = pathParam.name;
+    const paramType = pathParam.schema.type;
+    const paramFormat =
+      "format" in pathParam.schema
+        ? ` & tags.Format<'${pathParam.schema.format}'>`
+        : "";
+
+    const parameterField = `${paramName}: ${paramType}${paramFormat};`;
+    functionParameterFields.push(parameterField);
+  });
+
+  // Add request body if present (POST/PUT/PATCH operations)
+  const hasRequestBody = operation.requestBody?.typeName;
+  if (hasRequestBody) {
+    const bodyTypeName = operation.requestBody?.typeName;
+    functionParameterFields.push(`body: ${bodyTypeName};`);
+  }
+
+  // Format as TypeScript props interface or indicate no parameters needed
+  const hasParameters = functionParameterFields.length > 0;
+
+  if (!hasParameters) {
+    return `// No props parameter needed - function should have no parameters`;
+  }
+
+  const formattedFields = functionParameterFields
+    .map((field) => `  ${field}`)
+    .join("\n");
+
+  return StringUtil.trim`
+    props: {
+    ${formattedFields}
+    }`;
+}

package/src/orchestrate/realize/utils/replaceImportStatements.ts

@@ -1,133 +1,123 @@
-import { IAutoBeCompiler } from "@autobe/interface";
+import { AutoBeOpenApi, IAutoBeCompiler } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
 
 import { AutoBeContext } from "../../../context/AutoBeContext";
-import { IAutoBeTestScenarioArtifacts } from "../../test/structures/IAutoBeTestScenarioArtifacts";
+import { getRealizeWriteImportStatements } from "./getRealizeWriteImportStatements";
 
-export function replaceImportStatements<Model extends ILlmSchema.Model>(
+export async function replaceImportStatements<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
+  props: {
+    operation: AutoBeOpenApi.IOperation;
+    code: string;
+    decoratorType?: string;
+  },
 ) {
-  return async function (
-    artifacts: IAutoBeTestScenarioArtifacts,
-    code: string,
-    decoratorType?: string,
-  ) {
-    const typeReferences: string[] = Array.from(
-      new Set(
-        Object.keys(artifacts.document.components.schemas).map(
-          (key) => key.split(".")[0]!,
-        ),
-      ),
-    );
+  let { operation, code, decoratorType } = props;
 
-    const compiler: IAutoBeCompiler = await ctx.compiler();
-    code = await compiler.typescript.beautify(code);
-    // Remove existing import statements using flexible regex patterns
-    code = code
-      .replace(
-        /import\s*{\s*MyGlobal\s*}\s*from\s*["']\.\.\/MyGlobal["']\s*;?\s*/gm,
-        "",
-      )
-      .replace(
-        /import\s+typia\s*,\s*{\s*tags\s*}\s*from\s*["']typia["']\s*;?\s*/gm,
-        "",
-      )
-      .replace(/import\s*{\s*tags\s*}\s*from\s*["']typia["']\s*;?\s*/gm, "")
-      .replace(
-        /import\s*{\s*tags\s*,\s*typia\s*}\s*from\s*["']typia["']\s*;?\s*/gm,
-        "",
-      )
-      .replace(/import\s+typia\s*from\s*["']typia["']\s*;?\s*/gm, "")
-      .replace(
-        /import\s*{\s*Prisma\s*}\s*from\s*["']@prisma\/client["']\s*;?\s*/gm,
-        "",
-      )
-      .replace(/import\s*{\s*v4\s*}\s*from\s*["']uuid["']\s*;?\s*/gm, "")
-      .replace(
-        /import\s*{\s*toISOStringSafe\s*}\s*from\s*["']\.\.\/util\/toISOStringSafe["']\s*;?\s*/gm,
-        "",
-      )
-      // Remove JWT import if it exists (to prevent duplication)
-      .replace(/import\s+jwt\s+from\s*["']jsonwebtoken["']\s*;?\s*/gm, "")
-      .replace(
-        /import\s*\*\s*as\s+jwt\s+from\s*["']jsonwebtoken["']\s*;?\s*/gm,
-        "",
-      );
+  const typeReferences: string[] = Array.from(
+    new Set(
+      [operation.requestBody, operation.responseBody]
+        .filter((el) => el !== null)
+        .map((el) => el.typeName.split(".")[0]!),
+    ),
+  );
 
-    // Remove any existing API structure imports
-    // Pattern 1: ../api/structures path
-    code = code.replace(
-      /import\s*(?:type\s*)?{\s*[^}]+\s*}\s*from\s*["']\.\.\/api\/structures\/[^"']+["']\s*;?\s*/gm,
+  const compiler: IAutoBeCompiler = await ctx.compiler();
+  code = await compiler.typescript.beautify(code);
+  // Remove existing import statements using flexible regex patterns
+  code = code
+    .replace(
+      /import\s*{\s*MyGlobal\s*}\s*from\s*["']\.\.\/MyGlobal["']\s*;?\s*/gm,
       "",
-    );
-    // Pattern 2: @ORGANIZATION/PROJECT-api/lib/structures path
-    code = code.replace(
-      /import\s*(?:type\s*)?{\s*[^}]+\s*}\s*from\s*["']@ORGANIZATION\/PROJECT-api\/lib\/structures\/[^"']+["']\s*;?\s*/gm,
+    )
+    .replace(
+      /import\s+typia\s*,\s*{\s*tags\s*}\s*from\s*["']typia["']\s*;?\s*/gm,
+      "",
+    )
+    .replace(/import\s*{\s*tags\s*}\s*from\s*["']typia["']\s*;?\s*/gm, "")
+    .replace(
+      /import\s*{\s*tags\s*,\s*typia\s*}\s*from\s*["']typia["']\s*;?\s*/gm,
+      "",
+    )
+    .replace(/import\s+typia\s*from\s*["']typia["']\s*;?\s*/gm, "")
+    .replace(
+      /import\s*{\s*Prisma\s*}\s*from\s*["']@prisma\/client["']\s*;?\s*/gm,
+      "",
+    )
+    .replace(/import\s*{\s*v4\s*}\s*from\s*["']uuid["']\s*;?\s*/gm, "")
+    .replace(
+      /import\s*{\s*toISOStringSafe\s*}\s*from\s*["']\.\.\/util\/toISOStringSafe["']\s*;?\s*/gm,
+      "",
+    )
+    // Remove JWT import if it exists (to prevent duplication)
+    .replace(/import\s+jwt\s+from\s*["']jsonwebtoken["']\s*;?\s*/gm, "")
+    .replace(
+      /import\s*\*\s*as\s+jwt\s+from\s*["']jsonwebtoken["']\s*;?\s*/gm,
       "",
     );
 
-    // Remove specific type imports that match our typeReferences
-    for (const ref of typeReferences) {
-      // Remove any import of this specific type from any path
-      const typeImportRegex = new RegExp(
-        `import\\s*(?:type\\s*)?{\\s*${ref}\\s*}\\s*from\\s*["'][^"']+["']\\s*;?\\s*`,
-        "gm",
-      );
-      code = code.replace(typeImportRegex, "");
-    }
+  // Remove any existing API structure imports
+  // Pattern 1: ../api/structures path
+  code = code.replace(
+    /import\s*(?:type\s*)?{\s*[^}]+\s*}\s*from\s*["']\.\.\/api\/structures\/[^"']+["']\s*;?\s*/gm,
+    "",
+  );
+  // Pattern 2: @ORGANIZATION/PROJECT-api/lib/structures path
+  code = code.replace(
+    /import\s*(?:type\s*)?{\s*[^}]+\s*}\s*from\s*["']@ORGANIZATION\/PROJECT-api\/lib\/structures\/[^"']+["']\s*;?\s*/gm,
+    "",
+  );
 
-    // Remove any existing decoratorType imports if LLM mistakenly added them
-    if (decoratorType) {
-      const decoratorTypeRegex = new RegExp(
-        `import\\s*(?:type\\s*)?{\\s*${decoratorType}\\s*}\\s*from\\s*["']\\.\\.\/decorators\/payload\/${decoratorType}["']\\s*;?\\s*`,
-        "gm",
-      );
-      code = code.replace(decoratorTypeRegex, "");
-    }
+  // Remove specific type imports that match our typeReferences
+  for (const ref of typeReferences) {
+    // Remove any import of this specific type from any path
+    const typeImportRegex = new RegExp(
+      `import\\s*(?:type\\s*)?{\\s*${ref}\\s*}\\s*from\\s*["'][^"']+["']\\s*;?\\s*`,
+      "gm",
+    );
+    code = code.replace(typeImportRegex, "");
+  }
 
-    // Build the standard imports
-    const imports = [
-      'import jwt from "jsonwebtoken";',
-      'import { MyGlobal } from "../MyGlobal";',
-      'import typia, { tags } from "typia";',
-      'import { Prisma } from "@prisma/client";',
-      'import { v4 } from "uuid";',
-      'import { toISOStringSafe } from "../util/toISOStringSafe"',
-      ...typeReferences.map(
-        (ref) =>
-          `import { ${ref} } from "@ORGANIZATION/PROJECT-api/lib/structures/${ref}";`,
-      ),
-    ];
+  // Remove any existing decoratorType imports if LLM mistakenly added them
+  if (decoratorType) {
+    const decoratorTypeRegex = new RegExp(
+      `import\\s*(?:type\\s*)?{\\s*${decoratorType}\\s*}\\s*from\\s*["']\\.\\.\/decorators\/payload\/${decoratorType}["']\\s*;?\\s*`,
+      "gm",
+    );
+    code = code.replace(decoratorTypeRegex, "");
+  }
 
-    // Only add decoratorType import if it exists
-    if (decoratorType) {
-      imports.push(
-        `import { ${decoratorType} } from "../decorators/payload/${decoratorType}"`,
-      );
-    }
+  // Build the standard imports
+  const imports = getRealizeWriteImportStatements(operation);
+
+  // Only add decoratorType import if it exists
+  if (decoratorType) {
+    imports.push(
+      `import { ${decoratorType} } from "../decorators/payload/${decoratorType}"`,
+    );
+  }
 
-    code = [...imports, "", code].join("\n");
+  code = [...imports, "", code].join("\n");
 
-    // Clean up formatting issues
-    code =
-      code
-        // Remove lines with only whitespace
-        .replace(/^\s+$/gm, "")
-        // Replace 3+ consecutive newlines with exactly 2 newlines
-        .replace(/\n{3,}/g, "\n\n")
-        // Ensure proper spacing after import section
-        .replace(/(import.*?;)(\s*)(\n(?!import|\s*$))/g, "$1\n\n$3")
-        // Trim and ensure single trailing newline
-        .trim() + "\n";
+  // Clean up formatting issues
+  code =
+    code
+      // Remove lines with only whitespace
+      .replace(/^\s+$/gm, "")
+      // Replace 3+ consecutive newlines with exactly 2 newlines
+      .replace(/\n{3,}/g, "\n\n")
+      // Ensure proper spacing after import section
+      .replace(/(import.*?;)(\s*)(\n(?!import|\s*$))/g, "$1\n\n$3")
+      // Trim and ensure single trailing newline
+      .trim() + "\n";
 
-    // fix escaped codes
-    code = code.replace(/\\n/g, "\n").replace(/\\"/g, '"').replace(/\\'/g, "'");
+  // fix escaped codes
+  code = code.replace(/\\n/g, "\n").replace(/\\"/g, '"').replace(/\\'/g, "'");
 
-    // Apply final beautification
-    code = await compiler.typescript.beautify(code);
+  // Apply final beautification
+  code = await compiler.typescript.beautify(code);
 
-    code = code.replaceAll("typia.tags.assert", "typia.assert");
+  code = code.replaceAll("typia.tags.assert", "typia.assert");
 
-    return code;
-  };
+  return code;
 }