@autobe/agent 0.18.0 → 0.19.1

package/src/orchestrate/realize/orchestrateRealize.ts

@@ -9,11 +9,11 @@ import {
   IAutoBeTypeScriptCompileResult,
 } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
+import { v4 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
-import { getAutoBeGenerated } from "../../factory/getAutoBeGenerated";
-import { getAutoBeRealizeGenerated } from "../../factory/getAutoBeRealizeGenerated";
+import { predicateStateMessage } from "../../utils/predicateStateMessage";
 import { compile } from "./internal/compile";
 import { orchestrateRealizeAuthorization } from "./orchestrateRealizeAuthorization";
 import { orchestrateRealizeCorrect } from "./orchestrateRealizeCorrect";
@@ -26,13 +26,25 @@ export const orchestrateRealize =
   async (
     props: IAutoBeApplicationProps,
   ): Promise<AutoBeAssistantMessageHistory | AutoBeRealizeHistory> => {
+    // PREDICATION
     const operations: AutoBeOpenApi.IOperation[] | undefined =
       ctx.state().interface?.document.operations;
-    if (!operations) {
+    if (!operations)
       throw new Error("Can't do realize agent because operations are nothing.");
-    }
 
     const start: Date = new Date();
+    const predicate: string | null = predicateStateMessage(
+      ctx.state(),
+      "realize",
+    );
+    if (predicate !== null)
+      return ctx.assistantMessage({
+        type: "assistantMessage",
+        id: v4(),
+        created_at: start.toISOString(),
+        text: predicate,
+        completed_at: new Date().toISOString(),
+      });
     ctx.dispatch({
       type: "realizeStart",
       created_at: start.toISOString(),
@@ -40,35 +52,53 @@ export const orchestrateRealize =
       step: ctx.state().test?.step ?? 0,
     });
 
+    // AUTHORIZATIONS
     const authorizations: AutoBeRealizeAuthorization[] =
       await orchestrateRealizeAuthorization(ctx);
 
+    // SCENARIOS
     const scenarios: IAutoBeRealizeScenarioApplication.IProps[] =
-      operations.map((operation) => orchestrateRealizeScenario(ctx, operation));
+      operations.map((operation) => {
+        const authorization = authorizations.find(
+          (el) => el.role.name === operation.authorizationRole,
+        );
+
+        return orchestrateRealizeScenario(ctx, operation, authorization);
+      });
 
     const writeProgress = { total: scenarios.length, completed: 0 };
     const writeEvents: AutoBeRealizeWriteEvent[] = await Promise.all(
       scenarios.map(async (scenario) => {
-        const code = orchestrateRealizeWrite(
-          ctx,
-          scenario.decoratorEvent ?? null,
+        const code = orchestrateRealizeWrite(ctx, {
+          totalAuthorizations: authorizations,
+          authorization: scenario.decoratorEvent ?? null,
           scenario,
-          writeProgress,
-        );
+          progress: writeProgress,
+        });
         return code;
       }),
     );
 
-    let providers = Object.fromEntries(
-      writeEvents.map((event) => [event.location, event.content]),
-    );
-
-    let finalCompilationResult = await compile(ctx, {
-      authorizations,
-      providers,
+    const functions: AutoBeRealizeFunction[] = Object.entries(
+      Object.fromEntries(
+        writeEvents.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,
+      };
     });
 
-    if (finalCompilationResult.type !== "success") {
+    let compilation = await compile(ctx, { authorizations, functions });
+
+    if (compilation.type !== "success") {
       const MAX_CORRECTION_ATTEMPTS = 3 as const;
 
       const reviewProgress = {
@@ -77,65 +107,54 @@ export const orchestrateRealize =
       };
 
       for (let attempt = 0; attempt < MAX_CORRECTION_ATTEMPTS; attempt++) {
-        if (finalCompilationResult.result.type === "failure") {
-          const failedFiles: Record<string, string> =
-            finalCompilationResult.files;
+        if (compilation.type === "failure") {
+          const failedFiles: Record<string, string> = Object.fromEntries(
+            compilation.type === "failure"
+              ? compilation.diagnostics.map((d) => [d.file, d.code])
+              : [],
+          );
 
           reviewProgress.total += Object.keys(failedFiles).length;
-          const compilationResult: IAutoBeTypeScriptCompileResult.IFailure =
-            finalCompilationResult.result;
+          const failure: IAutoBeTypeScriptCompileResult.IFailure = compilation;
 
           await Promise.all(
             Object.entries(failedFiles).map(async ([location, content]) => {
               const diagnostic:
                 | IAutoBeTypeScriptCompileResult.IDiagnostic
-                | undefined = compilationResult.diagnostics.find(
+                | undefined = failure.diagnostics.find(
                 (el) => el.file === location,
               );
 
               const scenario = scenarios.find((el) => el.location === location);
               if (diagnostic && scenario) {
-                const correctEvent = await orchestrateRealizeCorrect(
-                  ctx,
-                  scenario.decoratorEvent ?? null,
+                const correctEvent = await orchestrateRealizeCorrect(ctx, {
+                  totalAuthorizations: authorizations,
+                  authorization: scenario.decoratorEvent ?? null,
                   scenario,
-                  content,
+                  code: content,
                   diagnostic,
-                  reviewProgress,
+                  progress: reviewProgress,
+                });
+
+                const corrected = functions.find(
+                  (el) => el.location === correctEvent.location,
                 );
 
-                providers[correctEvent.location] = correctEvent.content;
+                if (corrected) {
+                  corrected.content = correctEvent.content;
+                }
               }
             }),
           );
 
-          finalCompilationResult = await compile(ctx, {
-            authorizations,
-            providers,
-          });
-
-          if (finalCompilationResult.type === "success") {
+          compilation = await compile(ctx, { authorizations, functions });
+          if (compilation.type === "success") {
             break;
           }
         }
       }
     }
 
-    const functions: AutoBeRealizeFunction[] = Object.entries(providers).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,
-        };
-      },
-    );
-
     const compiler: IAutoBeCompiler = await ctx.compiler();
     const controllers: Record<string, string> =
       await compiler.realize.controller({
@@ -150,22 +169,7 @@ export const orchestrateRealize =
       functions,
       authorizations,
       controllers,
-      compiled: await compiler.typescript.compile({
-        files: {
-          ...(await getAutoBeGenerated(
-            compiler,
-            ctx.state(),
-            ctx.histories(),
-            ctx.usage(),
-          )),
-          ...(await getAutoBeRealizeGenerated({
-            document: ctx.state().interface!.document,
-            authorizations,
-            functions,
-            compiler,
-          })),
-        },
-      }),
+      compiled: await compile(ctx, { authorizations, functions }),
       step: ctx.state().analyze?.step ?? 0,
       elapsed: new Date().getTime() - start.getTime(),
     });

package/src/orchestrate/realize/orchestrateRealizeAuthorization.ts

@@ -1,6 +1,7 @@
 import { IAgenticaController } from "@agentica/core";
 import {
   AutoBeAnalyzeRole,
+  AutoBeProgressEventBase,
   AutoBeRealizeAuthorization,
   AutoBeRealizeAuthorizationWriteEvent,
   IAutoBeCompiler,
@@ -11,7 +12,6 @@ import typia from "typia";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
-import { IProgress } from "../internal/IProgress";
 import { transformRealizeAuthorizationHistories } from "./histories/transformRealizeAuthorization";
 import { orchestrateRealizeAuthorizationCorrect } from "./orchestrateRealizeAuthorizationCorrect";
 import { IAutoBeRealizeAuthorizationApplication } from "./structures/IAutoBeRealizeAuthorizationApplication";
@@ -34,7 +34,7 @@ export async function orchestrateRealizeAuthorization<
   });
 
   const roles: AutoBeAnalyzeRole[] = ctx.state().analyze?.roles ?? [];
-  const progress: IProgress = {
+  const progress: AutoBeProgressEventBase = {
     total: roles.length,
     completed: 0,
   };
@@ -63,7 +63,7 @@ async function process<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   role: AutoBeAnalyzeRole,
   templateFiles: Record<string, string>,
-  progress: IProgress,
+  progress: AutoBeProgressEventBase,
 ): Promise<AutoBeRealizeAuthorization> {
   const pointer: IPointer<IAutoBeRealizeAuthorizationApplication.IProps | null> =
     {

package/src/orchestrate/realize/orchestrateRealizeCorrect.ts

@@ -12,21 +12,24 @@ import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { getTestScenarioArtifacts } from "../test/compile/getTestScenarioArtifacts";
 import { IAutoBeTestScenarioArtifacts } from "../test/structures/IAutoBeTestScenarioArtifacts";
 import { transformRealizeCorrectHistories } from "./histories/transformRealizeCorrectHistories";
-import { IAutoBeRealizeCorrectApplication } from "./structures/IAutoBeRealizeReviewApplication";
+import { IAutoBeRealizeCorrectApplication } from "./structures/IAutoBeRealizeCorrectApplication";
 import { IAutoBeRealizeScenarioApplication } from "./structures/IAutoBeRealizeScenarioApplication";
 import { replaceImportStatements } from "./utils/replaceImportStatements";
 
 export async function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  authorization: AutoBeRealizeAuthorization | null,
-  scenario: IAutoBeRealizeScenarioApplication.IProps,
-  code: string,
-  diagnostic: IAutoBeTypeScriptCompileResult.IDiagnostic,
-  progress: IProgress,
+  props: {
+    authorization: AutoBeRealizeAuthorization | null;
+    totalAuthorizations: AutoBeRealizeAuthorization[];
+    scenario: IAutoBeRealizeScenarioApplication.IProps;
+    code: string;
+    diagnostic: IAutoBeTypeScriptCompileResult.IDiagnostic;
+    progress: IProgress;
+  },
 ): Promise<AutoBeRealizeCorrectEvent> {
   const artifacts: IAutoBeTestScenarioArtifacts =
     await getTestScenarioArtifacts(ctx, {
-      endpoint: scenario.operation,
+      endpoint: props.scenario.operation,
       dependencies: [],
     });
 
@@ -43,11 +46,12 @@ export async function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(
     }),
     histories: transformRealizeCorrectHistories({
       state: ctx.state(),
-      scenario,
+      scenario: props.scenario,
       artifacts,
-      authorization,
-      code,
-      diagnostic,
+      authorization: props.authorization,
+      code: props.code,
+      diagnostic: props.diagnostic,
+      totalAuthorizations: props.totalAuthorizations,
     }),
     enforceFunctionCall: true,
     message: [
@@ -62,16 +66,16 @@ export async function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(
   pointer.value.implementationCode = await replaceImportStatements(ctx)(
     artifacts,
     pointer.value.implementationCode,
-    authorization?.payload.name,
+    props.authorization?.payload.name,
   );
 
   const event: AutoBeRealizeCorrectEvent = {
     type: "realizeCorrect",
-    location: scenario.location,
+    location: props.scenario.location,
     content: pointer.value.implementationCode,
     tokenUsage,
-    completed: ++progress.completed,
-    total: progress.total,
+    completed: ++props.progress.completed,
+    total: props.progress.total,
     step: ctx.state().analyze?.step ?? 0,
     created_at: new Date().toISOString(),
   };

package/src/orchestrate/realize/orchestrateRealizeWrite.ts

@@ -17,13 +17,16 @@ import { replaceImportStatements } from "./utils/replaceImportStatements";
 
 export async function orchestrateRealizeWrite<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  authorization: AutoBeRealizeAuthorization | null,
-  scenario: IAutoBeRealizeScenarioApplication.IProps,
-  progress: IProgress,
+  props: {
+    totalAuthorizations: AutoBeRealizeAuthorization[];
+    authorization: AutoBeRealizeAuthorization | null;
+    scenario: IAutoBeRealizeScenarioApplication.IProps;
+    progress: IProgress;
+  },
 ): Promise<AutoBeRealizeWriteEvent> {
   const artifacts: IAutoBeTestScenarioArtifacts =
     await getTestScenarioArtifacts(ctx, {
-      endpoint: scenario.operation,
+      endpoint: props.scenario.operation,
       dependencies: [],
     });
   const pointer: IPointer<IAutoBeRealizeWriteApplication.IProps | null> = {
@@ -33,9 +36,10 @@ export async function orchestrateRealizeWrite<Model extends ILlmSchema.Model>(
     source: "realizeWrite",
     histories: transformRealizeWriteHistories({
       state: ctx.state(),
-      scenario,
+      scenario: props.scenario,
       artifacts,
-      authorization,
+      authorization: props.authorization,
+      totalAuthorizations: props.totalAuthorizations,
     }),
     controller: createController({
       model: ctx.model,
@@ -47,11 +51,15 @@ export async function orchestrateRealizeWrite<Model extends ILlmSchema.Model>(
     message: [
       `Write complete, production-ready TypeScript code that strictly follows these rules:`,
       "",
-      `1. Do **not** use the native \`Date\` type anywhere.`,
-      `2. All date or datetime values must be written as \`string & tags.Format<'date-time'>\`.`,
-      `3. UUIDs must be generated using \`v4()\` and typed as \`string & tags.Format<'uuid'>\`.`,
-      `4. Do not use \`as\` for type assertions — resolve types properly.`,
-      `5. All functions must be fully typed with clear parameter and return types.`,
+      `DO NOT:`,
+      `- Use the native \`Date\` type anywhere`,
+      `- Use \`as\` for type assertions`,
+      ``,
+      `DO:`,
+      `- Write all date/datetime values as \`string & tags.Format<'date-time'>\``,
+      `- Generate UUIDs using \`v4()\` and type as \`string & tags.Format<'uuid'>\``,
+      `- Resolve types properly without assertions`,
+      `- Type all functions with clear parameter and return types`,
       `6. Do not skip validations or default values where necessary.`,
       `7. Follow functional, immutable, and consistent code structure.`,
       "",
@@ -63,16 +71,16 @@ export async function orchestrateRealizeWrite<Model extends ILlmSchema.Model>(
   pointer.value.implementationCode = await replaceImportStatements(ctx)(
     artifacts,
     pointer.value.implementationCode,
-    authorization?.payload.name,
+    props.authorization?.payload.name,
   );
 
   const event: AutoBeRealizeWriteEvent = {
     type: "realizeWrite",
-    location: scenario.location,
+    location: props.scenario.location,
     content: pointer.value.implementationCode,
     tokenUsage,
-    completed: ++progress.completed,
-    total: progress.total,
+    completed: ++props.progress.completed,
+    total: props.progress.total,
     step: ctx.state().analyze?.step ?? 0,
     created_at: new Date().toISOString(),
   };

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

@@ -41,7 +41,7 @@ export namespace IAutoBeRealizeAuthorizationApplication {
      * called by the decorator to verify JWT tokens and return authenticated
      * user information for the specified role.
      *
-     * MUST use camelCase naming convention.
+     * DO: Use camelCase naming convention.
      */
     name: string & CamelPattern;
 
@@ -64,7 +64,7 @@ export namespace IAutoBeRealizeAuthorizationApplication {
      * authorize users for the specific role, injecting the authenticated user
      * payload as a method parameter.
      *
-     * MUST use PascalCase naming convention.
+     * DO: Use PascalCase naming convention.
      */
     name: string & PascalPattern;
 
@@ -86,7 +86,7 @@ export namespace IAutoBeRealizeAuthorizationApplication {
      * authenticated user data that will be injected into Controller methods
      * when using the decorator.
      *
-     * MUST use PascalCase naming convention.
+     * DO: Use PascalCase naming convention.
      */
     name: string & PascalPattern;
 

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

@@ -13,16 +13,18 @@ export namespace IAutoBeRealizeWriteApplication {
      * function according to the Realize Coder Agent specification. Before
      * writing the actual code, think through the logic and structure.
      *
-     * The plan MUST follow MANDATORY SCHEMA-FIRST APPROACH:
+     * The plan follows a SCHEMA-FIRST APPROACH:
      *
-     * 📋 STEP 1 - PRISMA SCHEMA VERIFICATION (MOST CRITICAL):
+     * 📋 STEP 1 - PRISMA SCHEMA VERIFICATION:
      *
-     * - 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 (e.g., "Note: deleted_at field
-     *   DOES NOT EXIST")
-     * - Common assumption errors to avoid: `deleted_at`, `created_by`,
-     *   `updated_by`, `is_deleted`, `is_active`
+     * 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
+     * 
+     * DO NOT:
+     * - Assume common fields exist without verification
+     * - Use fields like deleted_at, created_by, updated_by, is_deleted, is_active without checking
      *
      * 📋 STEP 2 - FIELD INVENTORY:
      *
@@ -158,8 +160,9 @@ export namespace IAutoBeRealizeWriteApplication {
      * Draft WITHOUT using native Date type.
      *
      * This is the initial drafting phase where you outline the basic skeleton
-     * of the function. CRITICAL: This draft must NEVER use the native Date
-     * type.
+     * of the function.
+     * 
+     * DO NOT: Use the native Date type.
      *
      * - The function signature must correctly include `user`, `parameters`, and
      *   `body` arguments.
@@ -168,13 +171,13 @@ export namespace IAutoBeRealizeWriteApplication {
      * - Mark any incomplete or missing parts clearly with placeholders (e.g.,
      *   comments or temporary values).
      *
-     * ⚠️ Import rules:
+     * Import rules:
      *
-     * - Do NOT add any new import statements manually.
-     * - All necessary imports are provided globally or by the system
-     *   automatically.
-     * - Writing import statements directly is prohibited and may cause compile
-     *   errors. If import errors occur, check your environment configuration.
+     * 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.
      *
      * ✅ Requirements:
      *

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

@@ -46,6 +46,12 @@ export function replaceImportStatements<Model extends ILlmSchema.Model>(
       .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 any existing API structure imports
@@ -81,6 +87,7 @@ export function replaceImportStatements<Model extends ILlmSchema.Model>(
 
     // Build the standard imports
     const imports = [
+      'import jwt from "jsonwebtoken";',
       'import { MyGlobal } from "../MyGlobal";',
       'import typia, { tags } from "typia";',
       'import { Prisma } from "@prisma/client";',