@autobe/agent 0.25.0 → 0.25.2

package/src/orchestrate/realize/orchestrateRealize.ts

@@ -5,6 +5,7 @@ import {
   AutoBeRealizeAuthorization,
   AutoBeRealizeFunction,
   AutoBeRealizeHistory,
+  AutoBeRealizeValidateEvent,
   AutoBeRealizeWriteEvent,
   IAutoBeCompiler,
 } from "@autobe/interface";
@@ -29,9 +30,9 @@ export const orchestrateRealize =
     props: IAutoBeApplicationProps,
   ): Promise<AutoBeAssistantMessageHistory | AutoBeRealizeHistory> => {
     // PREDICATION
-    const operations: AutoBeOpenApi.IOperation[] | undefined =
-      ctx.state().interface?.document.operations;
-    if (!operations)
+    const document: AutoBeOpenApi.IDocument | undefined =
+      ctx.state().interface?.document;
+    if (document === undefined)
       throw new Error("Can't do realize agent because operations are nothing.");
 
     const start: Date = new Date();
@@ -55,102 +56,150 @@ export const orchestrateRealize =
       step: ctx.state().test?.step ?? 0,
     });
 
-    // AUTHORIZATIONS
+    // PREPARE ASSETS
+    const compiler: IAutoBeCompiler = await ctx.compiler();
     const authorizations: AutoBeRealizeAuthorization[] =
       await orchestrateRealizeAuthorization(ctx);
 
-    // SCENARIOS
-    const scenarios: IAutoBeRealizeScenarioResult[] = operations.map(
-      (operation) => generateRealizeScenario(ctx, operation, authorizations),
-    );
-
     const writeProgress: AutoBeProgressEventBase = {
-      total: scenarios.length,
+      total: document.operations.length,
+      completed: 0,
+    };
+    const correctProgress: AutoBeProgressEventBase = {
+      total: document.operations.length,
       completed: 0,
     };
-    const writeEvents: (AutoBeRealizeWriteEvent | null)[] =
-      await executeCachedBatch(
-        scenarios.map((scenario) => async (promptCacheKey) => {
-          const props = {
-            totalAuthorizations: authorizations,
-            authorization: scenario.decoratorEvent ?? null,
-            scenario,
-            progress: writeProgress,
-            promptCacheKey,
-          };
-
-          const code: AutoBeRealizeWriteEvent | null =
-            await orchestrateRealizeWrite(ctx, props).catch(() => {
-              return orchestrateRealizeWrite(ctx, props).catch(() => null);
-            });
 
-          return code;
-        }),
+    const process = async (
+      artifacts: IAutoBeRealizeScenarioResult[],
+    ): Promise<IBucket> => {
+      const writes: AutoBeRealizeWriteEvent[] = (
+        await executeCachedBatch(
+          artifacts.map((art) => async (promptCacheKey) => {
+            const write = async (): Promise<AutoBeRealizeWriteEvent | null> => {
+              try {
+                return await orchestrateRealizeWrite(ctx, {
+                  totalAuthorizations: authorizations,
+                  authorization: art.decoratorEvent ?? null,
+                  scenario: art,
+                  document,
+                  progress: writeProgress,
+                  promptCacheKey,
+                });
+              } catch {
+                return null;
+              }
+            };
+            return (await write()) ?? (await write());
+          }),
+        )
+      ).filter((w) => w !== null);
+      const functions: AutoBeRealizeFunction[] = Object.entries(
+        Object.fromEntries(writes.map((w) => [w.location, w.content])),
+      ).map(([location, content]) => {
+        const scenario: IAutoBeRealizeScenarioResult = artifacts.find(
+          (el) => el.location === location,
+        )!;
+        return {
+          location,
+          content,
+          endpoint: {
+            method: scenario.operation.method,
+            path: scenario.operation.path,
+          },
+          name: scenario.functionName,
+        };
+      });
+      const corrected: AutoBeRealizeFunction[] =
+        await orchestrateRealizeCorrectCasting(
+          ctx,
+          artifacts,
+          authorizations,
+          functions,
+          correctProgress,
+        ).then(async (res) => {
+          return await orchestrateRealizeCorrect(
+            ctx,
+            artifacts,
+            authorizations,
+            res,
+            [],
+            correctProgress,
+          );
+        });
+      const validate: AutoBeRealizeValidateEvent = await compileRealizeFiles(
+        ctx,
+        {
+          authorizations,
+          functions: corrected,
+        },
       );
-
-    const functions: AutoBeRealizeFunction[] = Object.entries(
-      Object.fromEntries(
-        writeEvents
-          .filter((w) => w !== null)
-          .map((event) => [event.location, event.content]),
-      ),
-    ).map(([location, content]) => {
-      const scenario = scenarios.find((el) => el.location === location)!;
       return {
-        location,
-        content,
-        endpoint: {
-          method: scenario.operation.method,
-          path: scenario.operation.path,
-        },
-        name: scenario.functionName,
+        corrected,
+        validate,
       };
-    });
-
-    const reviewProgress: AutoBeProgressEventBase = {
-      total: writeEvents.length,
-      completed: writeEvents.length,
     };
 
-    const totalCorrected: AutoBeRealizeFunction[] =
-      await orchestrateRealizeCorrectCasting(
-        ctx,
-        authorizations,
-        functions,
-        reviewProgress,
-      ).then(async (res) => {
-        return orchestrateRealizeCorrect(
-          ctx,
-          scenarios,
-          authorizations,
-          res,
-          [],
-          reviewProgress,
-        );
-      });
+    // SCENARIOS
+    const entireScenarios: IAutoBeRealizeScenarioResult[] =
+      document.operations.map((operation) =>
+        generateRealizeScenario(ctx, operation, authorizations),
+      );
+    let bucket: IBucket = await process(entireScenarios);
+    for (let i: number = 0; i < 2; ++i) {
+      if (bucket.validate.result.type !== "failure") break;
+
+      const failedScenarios: IAutoBeRealizeScenarioResult[] = Array.from(
+        new Set(bucket.validate.result.diagnostics.map((f) => f.file)),
+      )
+        .map((location) =>
+          bucket.corrected.find((f) => f.location === location),
+        )
+        .filter((f) => f !== undefined)
+        .map((f) =>
+          entireScenarios.find(
+            (s) =>
+              s.operation.path === f.endpoint.path &&
+              s.operation.method === f.endpoint.method,
+          ),
+        )
+        .filter((o) => o !== undefined);
+      if (failedScenarios.length === 0) break;
+
+      writeProgress.total += failedScenarios.length;
+      correctProgress.total += failedScenarios.length;
+
+      const newBucket: IBucket = await process(failedScenarios);
+      const corrected: Map<string, AutoBeRealizeFunction> = new Map([
+        ...bucket.corrected.map((f) => [f.location, f] as const),
+        ...newBucket.corrected.map((f) => [f.location, f] as const),
+      ]);
+      bucket = {
+        corrected: Array.from(corrected.values()),
+        validate: newBucket.validate,
+      };
+    }
 
-    const compiler: IAutoBeCompiler = await ctx.compiler();
     const controllers: Record<string, string> =
       await compiler.realize.controller({
         document: ctx.state().interface!.document,
-        functions: totalCorrected,
+        functions: bucket.corrected,
         authorizations,
       });
-
-    const { result } = await compileRealizeFiles(ctx, {
-      authorizations,
-      functions: totalCorrected,
-    });
-
     return ctx.dispatch({
       type: "realizeComplete",
       id: v7(),
       created_at: new Date().toISOString(),
-      functions: totalCorrected,
+      functions: bucket.corrected,
       authorizations,
       controllers,
-      compiled: result,
+      compiled: bucket.validate.result,
       step: ctx.state().analyze?.step ?? 0,
       elapsed: new Date().getTime() - start.getTime(),
     });
   };
+
+interface IBucket {
+  corrected: AutoBeRealizeFunction[];
+  validate: AutoBeRealizeValidateEvent;
+}

package/src/orchestrate/realize/orchestrateRealizeCorrect.ts

@@ -19,6 +19,7 @@ import { IAutoBeRealizeCorrectApplication } from "./structures/IAutoBeRealizeCor
 import { IAutoBeRealizeFunctionFailure } from "./structures/IAutoBeRealizeFunctionFailure";
 import { IAutoBeRealizeScenarioResult } from "./structures/IAutoBeRealizeScenarioResult";
 import { filterDiagnostics } from "./utils/filterDiagnostics";
+import { getRealizeWriteCodeTemplate } from "./utils/getRealizeWriteCodeTemplate";
 import { getRealizeWriteDto } from "./utils/getRealizeWriteDto";
 import { replaceImportStatements } from "./utils/replaceImportStatements";
 
@@ -42,7 +43,9 @@ export async function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(
   const diagnostics = event.result.diagnostics;
 
   if (
-    event.result.diagnostics.every((d) => !d.file?.startsWith("src/providers"))
+    event.result.diagnostics.every(
+      (d) => !d.file?.startsWith("src/providers"),
+    ) === true
   ) {
     // No diagnostics related to provider functions, stop correcting
     return functions;
@@ -99,7 +102,6 @@ export async function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(
     ),
     progress,
   );
-
   return orchestrateRealizeCorrect(
     ctx,
     scenarios,
@@ -211,6 +213,23 @@ async function step<Model extends ILlmSchema.Model>(
     enforceFunctionCall: true,
     message: StringUtil.trim`
       Correct the TypeScript code implementation.
+
+      The instruction to write at first was as follows, and the code you received is the code you wrote according to this instruction.
+      When modifying, modify the entire code, but not the import statement.
+
+      Below is template code you wrote:
+      
+      ${getRealizeWriteCodeTemplate({
+        scenario: props.scenario,
+        schemas: ctx.state().interface!.document.components.schemas,
+        operation: props.scenario.operation,
+        authorization: props.authorization ?? null,
+      })}
+
+      Current code is as follows:
+      \`\`\`typescript
+      ${props.function.content}
+      \`\`\`
     `,
   });
 
@@ -218,17 +237,25 @@ async function step<Model extends ILlmSchema.Model>(
     return null;
   }
 
-  pointer.value.revise.final = await replaceImportStatements(ctx, {
+  pointer.value.draft = await replaceImportStatements(ctx, {
     operation: props.scenario.operation,
-    code: pointer.value.revise.final,
+    schemas: ctx.state().interface!.document.components.schemas,
+    code: pointer.value.draft,
     decoratorType: props.authorization?.payload.name,
   });
+  if (pointer.value.revise.final)
+    pointer.value.revise.final = await replaceImportStatements(ctx, {
+      operation: props.scenario.operation,
+      schemas: ctx.state().interface!.document.components.schemas,
+      code: pointer.value.revise.final,
+      decoratorType: props.authorization?.payload.name,
+    });
 
   const event: AutoBeRealizeCorrectEvent = {
     type: "realizeCorrect",
     id: v7(),
     location: props.scenario.location,
-    content: pointer.value.revise.final,
+    content: pointer.value.revise.final ?? pointer.value.draft,
     tokenUsage,
     completed: ++props.progress.completed,
     total: props.progress.total,
@@ -253,7 +280,7 @@ function createController<Model extends ILlmSchema.Model>(props: {
     name: "Write code",
     application,
     execute: {
-      review: (next) => {
+      correct: (next) => {
         props.build(next);
       },
     } satisfies IAutoBeRealizeCorrectApplication,

package/src/orchestrate/realize/orchestrateRealizeWrite.ts

@@ -1,4 +1,5 @@
 import {
+  AutoBeOpenApi,
   AutoBeProgressEventBase,
   AutoBeRealizeAuthorization,
   AutoBeRealizeWriteEvent,
@@ -20,6 +21,7 @@ import { replaceImportStatements } from "./utils/replaceImportStatements";
 export async function orchestrateRealizeWrite<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   props: {
+    document: AutoBeOpenApi.IDocument;
     totalAuthorizations: AutoBeRealizeAuthorization[];
     authorization: AutoBeRealizeAuthorization | null;
     scenario: IAutoBeRealizeScenarioResult;
@@ -69,17 +71,25 @@ export async function orchestrateRealizeWrite<Model extends ILlmSchema.Model>(
   });
   if (pointer.value === null) throw new Error("Failed to write code.");
 
-  pointer.value.final = await replaceImportStatements(ctx, {
+  pointer.value.draft = await replaceImportStatements(ctx, {
     operation: props.scenario.operation,
-    code: pointer.value.final,
+    schemas: props.document.components.schemas,
+    code: pointer.value.draft,
     decoratorType: props.authorization?.payload.name,
   });
+  if (pointer.value.revise.final)
+    pointer.value.revise.final = await replaceImportStatements(ctx, {
+      operation: props.scenario.operation,
+      schemas: props.document.components.schemas,
+      code: pointer.value.revise.final,
+      decoratorType: props.authorization?.payload.name,
+    });
 
   const event: AutoBeRealizeWriteEvent = {
     type: "realizeWrite",
     id: v7(),
     location: props.scenario.location,
-    content: pointer.value.final,
+    content: pointer.value.revise.final ?? pointer.value.draft,
     tokenUsage,
     completed: ++props.progress.completed,
     total: props.progress.total,
@@ -105,7 +115,7 @@ function createController<Model extends ILlmSchema.Model>(props: {
     name: "Write code",
     application,
     execute: {
-      coding: (next) => {
+      write: (next) => {
         props.build(next);
       },
     } satisfies IAutoBeRealizeWriteApplication,

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

@@ -1,22 +1,30 @@
-import { CamelPattern, PascalPattern } from "@autobe/interface";
+import { CamelCasePattern, PascalCasePattern } from "@autobe/interface";
 
 export interface IAutoBeRealizeAuthorizationApplication {
   /**
-   * Generates authentication provider, decorator, and payload type for role-based authorization.
+   * Generates authentication provider, decorator, and payload type for
+   * role-based authorization.
    *
    * This method creates a complete authentication infrastructure for a specific
-   * role in the NestJS application. It generates three interconnected components
-   * that work together to provide JWT-based authentication and authorization.
+   * role in the NestJS application. It generates three interconnected
+   * components that work together to provide JWT-based authentication and
+   * authorization.
    *
    * The generated components include:
-   * - **Provider Function**: Handles JWT verification and user validation from database
-   * - **Decorator**: NestJS parameter decorator for injecting authenticated user data
-   * - **Payload Type**: TypeScript interface defining the authenticated user structure
    *
-   * All components follow strict naming conventions and integrate with the existing
-   * authentication architecture using the shared jwtAuthorize function.
+   * - **Provider Function**: Handles JWT verification and user validation from
+   *   database
+   * - **Decorator**: NestJS parameter decorator for injecting authenticated user
+   *   data
+   * - **Payload Type**: TypeScript interface defining the authenticated user
+   *   structure
    *
-   * @param next Properties containing provider, decorator, and payload type configurations
+   * All components follow strict naming conventions and integrate with the
+   * existing authentication architecture using the shared jwtAuthorize
+   * function.
+   *
+   * @param next Properties containing provider, decorator, and payload type
+   *   configurations
    */
   createDecorator: (
     next: IAutoBeRealizeAuthorizationApplication.IProps,
@@ -60,7 +68,7 @@ export namespace IAutoBeRealizeAuthorizationApplication {
      *
      * DO: Use camelCase naming convention.
      */
-    name: string & CamelPattern;
+    name: string & CamelCasePattern;
 
     /**
      * Complete TypeScript code for the authentication Provider function. Must
@@ -83,7 +91,7 @@ export namespace IAutoBeRealizeAuthorizationApplication {
      *
      * DO: Use PascalCase naming convention.
      */
-    name: string & PascalPattern;
+    name: string & PascalCasePattern;
 
     /**
      * Complete TypeScript code for the authentication Decorator implementation.
@@ -105,7 +113,7 @@ export namespace IAutoBeRealizeAuthorizationApplication {
      *
      * DO: Use PascalCase naming convention.
      */
-    name: string & PascalPattern;
+    name: string & PascalCasePattern;
 
     /**
      * Complete TypeScript code for the Payload type interface in {Role}Payload

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

@@ -1,45 +1,70 @@
 export interface IAutoBeRealizeCorrectApplication {
   /**
-   * Reviews and corrects TypeScript compilation errors.
+   * Systematically analyze and correct TypeScript compilation errors.
    *
-   * Fixes TypeScript compilation errors while preserving original business
-   * logic, applying minimal intervention principle.
+   * Implements a three-phase workflow (think → draft → revise) that balances
+   * efficiency for simple errors with thoroughness for complex problems.
    *
-   * @param props Properties containing the multi-phase error correction process
+   * @param props Three-phase correction properties
    */
-  review: (props: IAutoBeRealizeCorrectApplication.IProps) => void;
+  correct(props: IAutoBeRealizeCorrectApplication.IProps): void;
 }
 
 export namespace IAutoBeRealizeCorrectApplication {
-  /**
-   * Properties for error correction following Chain of Thinking (CoT).
-   *
-   * All phases are wrapped in a `revise` object for systematic error
-   * resolution.
-   */
   export interface IProps {
-    /** Revision process containing all error correction phases. */
-    revise: IRevise;
-  }
-
-  export interface IRevise {
-    /** 
-     * Step 1: TypeScript compilation error analysis and resolution strategy.
-     * Analyzes TypeScript compiler diagnostics (error codes, messages) to understand
-     * type mismatches, missing properties, nullable conflicts, and other compilation issues.
+    /**
+     * Initial error analysis and correction strategy.
+     *
+     * Analyzes TypeScript compilation errors to understand:
+     *
+     * - Error patterns and root causes
+     * - Required fixes and their impact
+     * - Whether quick fixes or deep refactoring is needed
+     * - Prisma schema and API contract constraints
      */
-    errorAnalysis?: string;
+    think: string;
 
-    /** Step 2: Provider function implementation plan. */
-    plan?: string;
+    /**
+     * First correction attempt.
+     *
+     * Implements the initial fixes identified in the think phase. For simple
+     * errors (typos, missing imports), this may be the final solution. Complex
+     * errors may require further refinement.
+     */
+    draft: string;
 
-    /** Step 3: Relevant Prisma schema definitions. */
-    prismaSchemas?: string;
+    /**
+     * Revision and finalization phase.
+     *
+     * Reviews the draft corrections and produces the final, error-free code
+     * that maintains all business requirements.
+     */
+    revise: IReviseProps;
+  }
 
-    /** Step 4: Refined version with improved completeness. */
-    review?: string;
+  export interface IReviseProps {
+    /**
+     * Correction review and validation.
+     *
+     * Analyzes the draft corrections to ensure:
+     *
+     * - All TypeScript errors are resolved
+     * - Business logic remains intact
+     * - AutoBE coding standards are maintained
+     * - No new errors are introduced
+     * - Performance and security are preserved
+     */
+    review: string;
 
-    /** Step 5: Final complete TypeScript function implementation. */
-    final: string;
+    /**
+     * Final error-free implementation.
+     *
+     * The complete, corrected code that passes all TypeScript compilation
+     * checks.
+     *
+     * Returns `null` if the draft corrections are sufficient and need no
+     * further changes.
+     */
+    final: string | null;
   }
 }

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

@@ -1,55 +1,66 @@
 export interface IAutoBeRealizeWriteApplication {
   /**
-   * Generates provider function implementation through multi-phase development.
+   * Generate complete provider function implementation using Chain of Thinking.
    *
-   * 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.
+   * Follows a 3-phase process: plan → draft → revise.
    *
-   * The generation process includes:
+   * Ensures type safety, proper Prisma usage, and API contract compliance.
    *
-   * 1. Strategic planning based on Prisma schema analysis
-   * 2. Schema definition for relevant models
-   * 3. Review and refinement for completeness
-   * 4. Final implementation with all validations and type safety
-   *
-   * @param next Properties containing the multi-phase implementation plan and
-   *   code
+   * @param props Chain of Thinking properties for implementation
    */
-  coding: (next: IAutoBeRealizeWriteApplication.IProps) => void;
+  write(props: 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 implementation process.
-   * Detailed guidelines are in REALIZE_WRITE.md.
-   */
   export interface IProps {
     /**
-     * Step 1 - Planning Phase (CoT: Initial Reasoning)
-     *
-     * Strategic plan following SCHEMA-FIRST APPROACH:
-     *
-     * 1. Verify Prisma schema fields (list existing and non-existing)
-     * 2. Plan field usage in operations
-     * 3. Plan type conversions and nullable handling
-     * 4. Define implementation approach with error handling
+     * Implementation plan and strategy.
      *
-     * See REALIZE_WRITE.md for detailed requirements.
+     * Analyzes the provider function requirements, identifies related Prisma
+     * schemas, and outlines the implementation approach. Includes schema
+     * validation and API contract verification.
      */
     plan: string;
 
-    /** Step 2 - Relevant Prisma schema models and fields */
-    prismaSchemas: string;
+    /**
+     * Initial implementation draft.
+     *
+     * The first complete implementation attempt based on the plan. May contain
+     * areas that need refinement in the review phase.
+     */
+    draft: string;
+
+    /**
+     * Revision and finalization phase.
+     *
+     * Reviews the draft implementation and produces the final code with all
+     * improvements and corrections applied.
+     */
+    revise: IReviseProps;
+  }
 
-    /** Step 3 - Refined version with real operations */
+  export interface IReviseProps {
+    /**
+     * Review and improvement suggestions.
+     *
+     * Identifies areas for improvement in the draft code, including:
+     *
+     * - Type safety enhancements
+     * - Prisma query optimizations
+     * - Null/undefined handling corrections
+     * - Authentication/authorization improvements
+     * - Error handling refinements
+     */
     review: string;
 
-    /** Step 4 - Final implementation See REALIZE_WRITE.md for requirements */
-    final: string;
+    /**
+     * Final implementation code.
+     *
+     * The complete, production-ready implementation with all review suggestions
+     * applied.
+     *
+     * Returns `null` if the draft is already perfect and needs no changes.
+     */
+    final: string | null;
   }
 }

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

@@ -7,6 +7,6 @@ export namespace InternalFileSystem {
   export const DEFAULT = [
     "src/providers/authorize/jwtAuthorize.ts",
     "src/MyGlobal.ts",
-    "src/util/toISOStringSafe.ts",
+    "src/utils/toISOStringSafe.ts",
   ];
 }