@autobe/agent 0.11.2 → 0.12.0

package/src/factory/getAutoBeGenerated.ts

@@ -3,23 +3,19 @@ import {
   IAutoBeCompiler,
   IAutoBeGetFilesOptions,
 } from "@autobe/interface";
-import { ILlmSchema } from "@samchon/openapi";
-import typia from "typia";
 
-import { AutoBeContext } from "../context/AutoBeContext";
 import { AutoBeState } from "../context/AutoBeState";
 import { AutoBeTokenUsage } from "../context/AutoBeTokenUsage";
 
-export async function getAutoBeGenerated<Model extends ILlmSchema.Model>(
-  ctx: AutoBeContext<Model>,
+export async function getAutoBeGenerated(
+  compiler: IAutoBeCompiler,
+  state: AutoBeState,
   histories: AutoBeHistory[],
   tokenUsage: AutoBeTokenUsage,
   options?: Partial<IAutoBeGetFilesOptions>,
 ): Promise<Record<string, string>> {
-  const state: AutoBeState = ctx.state();
-  const ret: Record<string, string> = {};
-
   // ANALYZE
+  const ret: Record<string, string> = {};
   if (state.analyze === null) return {};
   Object.assign<Record<string, string>, Record<string, string>>(
     ret,
@@ -32,7 +28,6 @@ export async function getAutoBeGenerated<Model extends ILlmSchema.Model>(
   );
 
   // PRISMA
-  const compiler: IAutoBeCompiler = await ctx.compiler();
   if (state.prisma?.step === state.analyze.step) {
     const schemaFiles: Record<string, string> =
       (options?.dbms ?? "postgres") === "postgres"
@@ -51,7 +46,7 @@ export async function getAutoBeGenerated<Model extends ILlmSchema.Model>(
         ]),
       ),
       {
-        "autobe/prisma.json": typia.json.stringify(state.prisma.result.data),
+        "autobe/prisma.json": JSON.stringify(state.prisma.result.data),
       },
     );
     if (state.prisma.compiled.type === "success")
@@ -79,7 +74,7 @@ export async function getAutoBeGenerated<Model extends ILlmSchema.Model>(
           )
         : files,
       {
-        "autobe/document.json": typia.json.stringify(state.interface.document),
+        "autobe/document.json": JSON.stringify(state.interface.document),
       },
     );
   }
@@ -106,8 +101,8 @@ export async function getAutoBeGenerated<Model extends ILlmSchema.Model>(
 
   // LOGGING
   Object.assign<Record<string, string>, Record<string, string>>(ret, {
-    "autobe/histories.json": typia.json.stringify(histories),
-    "autobe/tokenUsage.json": typia.json.stringify(tokenUsage),
+    "autobe/histories.json": JSON.stringify(histories),
+    "autobe/tokenUsage.json": JSON.stringify(tokenUsage),
   });
   return ret;
 }

package/src/index.ts

@@ -1,5 +1,4 @@
 export * from "./AutoBeAgent";
-
 export * from "./context/AutoBeTokenUsage";
 
 export * from "./structures/IAutoBeProps";
@@ -11,3 +10,6 @@ export * as factory from "./factory";
 
 /** @internal */
 export * as orchestrate from "./orchestrate";
+
+/** @internal */
+export * from "./AutoBeMockAgent";

package/src/orchestrate/analyze/orchestrateAnalyze.ts

@@ -70,6 +70,11 @@ export const orchestrateAnalyze =
       return history;
     }
 
+    const retryCount = 3 as const;
+    const progress = {
+      total: tableOfContents.length * retryCount,
+      completed: 0,
+    };
     const pointers = await Promise.all(
       tableOfContents.map(async ({ filename }) => {
         const pointer: AutoBeAnalyzePointer = { value: { files: {} } };
@@ -79,7 +84,8 @@ export const orchestrateAnalyze =
           tableOfContents,
           filename,
           roles,
-          3,
+          progress,
+          retryCount,
         );
         return pointer;
       }),

package/src/orchestrate/analyze/writeDocumentUntilReviewPassed.ts

@@ -16,6 +16,7 @@ export async function writeDocumentUntilReviewPassed<
   totalFiles: Pick<IFile, "filename" | "reason">[],
   filename: string,
   roles: AutoBeAnalyzeRole[],
+  progress: { total: number; completed: number },
   retry = 3,
 ): Promise<AutoBeAnalyzePointer> {
   const isAborted: IPointer<boolean> = { value: false };
@@ -38,16 +39,21 @@ export async function writeDocumentUntilReviewPassed<
       pointer,
       isAborted,
     );
+
     await writer.conversate(review ?? write).finally(() => {
       const tokenUsage = writer.getTokenUsage();
       ctx.usage().record(tokenUsage, ["analyze"]);
     });
+
     if (pointer.value === null) {
       throw new Error("Failed to write document by unknown reason.");
     }
+
     ctx.dispatch({
       type: "analyzeWrite",
       files: pointer.value.files,
+      total: progress.total,
+      completed: ++progress.completed,
       step: ctx.state().analyze?.step ?? 0,
       created_at: new Date().toISOString(),
     });
@@ -58,6 +64,8 @@ export async function writeDocumentUntilReviewPassed<
       ctx.dispatch({
         type: "analyzeReview",
         review,
+        total: progress.total,
+        completed: progress.completed,
         step: ctx.state().analyze?.step ?? 0,
         created_at: new Date().toISOString(),
       });

package/src/orchestrate/realize/orchestrateRealize.ts

@@ -7,6 +7,7 @@ import { v4 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
+import { orchestrateRealizeDecorator } from "./orchestrateRealizeDecorator";
 import { writeCodeUntilCompilePassed } from "./writeCodeUntilCompilePassed";
 
 export const orchestrateRealize =
@@ -20,6 +21,16 @@ export const orchestrateRealize =
       throw new Error("Can't do realize agent because operations are nothing.");
     }
 
+    ctx.dispatch({
+      type: "realizeStart",
+      created_at: new Date().toISOString(),
+      reason: props.reason,
+      step: ctx.state().test?.step ?? 0,
+    });
+
+    const decorators = await orchestrateRealizeDecorator(ctx);
+    decorators;
+
     await writeCodeUntilCompilePassed(ctx, ops, 3);
     const now = new Date().toISOString();
     ctx.dispatch({

package/src/orchestrate/realize/orchestrateRealizeCoder.ts

@@ -10,6 +10,10 @@ import typia from "typia";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
+import {
+  randomBackoffRetry,
+  randomBackoffStrategy,
+} from "../../utils/backoffRetry";
 import { enforceToolCall } from "../../utils/enforceToolCall";
 import { getTestScenarioArtifacts } from "../test/compile/getTestScenarioArtifacts";
 import { IAutoBeTestScenarioArtifacts } from "../test/structures/IAutoBeTestScenarioArtifacts";
@@ -50,6 +54,7 @@ export const orchestrateRealizeCoder = async <Model extends ILlmSchema.Model>(
     >
   | FAILED
 > => {
+  total;
   const artifacts: IAutoBeTestScenarioArtifacts =
     await getTestScenarioArtifacts(ctx, {
       endpoint: {
@@ -79,6 +84,7 @@ export const orchestrateRealizeCoder = async <Model extends ILlmSchema.Model>(
     vendor: ctx.vendor,
     config: {
       ...ctx.config,
+      backoffStrategy: randomBackoffStrategy,
       executor: {
         describe: null,
       },
@@ -88,15 +94,31 @@ export const orchestrateRealizeCoder = async <Model extends ILlmSchema.Model>(
       props,
       artifacts,
       previous,
-      total,
       diagnostics,
     ),
   });
   enforceToolCall(agent);
 
-  await agent.conversate("Write code.");
-  const tokenUsage = agent.getTokenUsage();
-  ctx.usage().record(tokenUsage, ["realize"]);
+  await randomBackoffRetry(() =>
+    agent.conversate(
+      [
+        `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.`,
+        `6. Do not skip validations or default values where necessary.`,
+        `7. Follow functional, immutable, and consistent code structure.`,
+        "",
+        `Use \`@nestia/e2e\` test structure if relevant.`,
+      ].join("\n"),
+    ),
+  ).finally(() => {
+    const tokenUsage = agent.getTokenUsage();
+    ctx.usage().record(tokenUsage, ["realize"]);
+  });
 
   if (pointer.value === null) {
     return FAILED;

package/src/orchestrate/realize/orchestrateRealizeDecorator.ts

@@ -0,0 +1,286 @@
+import { IAgenticaController, MicroAgentica } from "@agentica/core";
+import {
+  AutoBeRealizeDecoratorEvent,
+  IAutoBeCompiler,
+} from "@autobe/interface";
+import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
+import fs from "fs/promises";
+import path from "path";
+import { IPointer } from "tstl";
+import typia from "typia";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { assertSchemaModel } from "../../context/assertSchemaModel";
+import { enforceToolCall } from "../../utils/enforceToolCall";
+import { IAutoBeRealizeDecoratorApplication } from "./structures/IAutoBeRealizeDecoratorApplication";
+import { transformRealizeDecoratorHistories } from "./transformRealizeDecorator";
+import { transformRealizeDecoratorCorrectHistories } from "./transformRealizeDecoratorCorrectHistories";
+
+/**
+ * 1. Create decorator and its parameters. and design the Authorization Provider.
+ * 2. According to Authorization Provider design, create the Provider.
+ *
+ * @param ctx
+ */
+export async function orchestrateRealizeDecorator<
+  Model extends ILlmSchema.Model,
+>(
+  ctx: AutoBeContext<Model>,
+): Promise<IAutoBeRealizeDecoratorApplication.IProps[]> {
+  const roles =
+    ctx
+      .state()
+      .interface?.document.components.authorization?.map((auth) => auth.name) ??
+    [];
+
+  const decorators: IAutoBeRealizeDecoratorApplication.IProps[] = [];
+
+  let completed = 0;
+
+  const templateFiles = {
+    "src/MyGlobal.ts": await fs.readFile(
+      path.join(
+        __dirname,
+        "../../../../../internals/template/realize/src/MyGlobal.ts",
+      ),
+      "utf-8",
+    ),
+    "src/authentications/jwtAuthorize.ts": await fs.readFile(
+      path.join(
+        __dirname,
+        "../../../../../internals/template/realize/src/providers/jwtAuthorize.ts",
+      ),
+      "utf-8",
+    ),
+  };
+
+  const files: Record<string, string> = {
+    ...templateFiles,
+  };
+
+  await Promise.all(
+    roles.map(async (role) => {
+      const decorator: IAutoBeRealizeDecoratorApplication.IProps =
+        await process(ctx, role, templateFiles);
+
+      files[`src/decorators/${decorator.decorator.name}.ts`] =
+        decorator.decorator.code;
+      files[`src/authentications/${decorator.provider.name}.ts`] =
+        decorator.provider.code;
+      files[`src/authentications/types/${decorator.decoratorType.name}.ts`] =
+        decorator.decoratorType.code;
+
+      decorators.push(decorator);
+
+      const events: AutoBeRealizeDecoratorEvent = {
+        type: "realizeDecorator",
+        created_at: new Date().toISOString(),
+        files,
+        completed: ++completed,
+        total: roles.length,
+        step: ctx.state().test?.step ?? 0,
+      };
+
+      ctx.dispatch(events);
+    }),
+  );
+
+  return decorators;
+}
+
+async function process<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  role: string,
+  templateFiles: Record<string, string>,
+): Promise<IAutoBeRealizeDecoratorApplication.IProps> {
+  const pointer: IPointer<IAutoBeRealizeDecoratorApplication.IProps | null> = {
+    value: null,
+  };
+
+  const agentica: MicroAgentica<Model> = new MicroAgentica({
+    model: ctx.model,
+    vendor: ctx.vendor,
+    config: {
+      ...(ctx.config ?? {}),
+      executor: {
+        describe: null,
+      },
+    },
+    histories: transformRealizeDecoratorHistories(ctx, role),
+    controllers: [
+      createApplication({
+        model: ctx.model,
+        build: (next) => {
+          pointer.value = next;
+        },
+      }),
+    ],
+  });
+
+  enforceToolCall(agentica);
+
+  await agentica
+    .conversate("Create Authorization Provider and Decorator.")
+    .finally(() => {
+      const tokenUsage = agentica.getTokenUsage();
+      ctx.usage().record(tokenUsage, ["realize"]);
+    });
+
+  if (pointer.value === null) throw new Error("Failed to create decorator.");
+
+  const compiled = ctx.state().prisma?.compiled;
+
+  const prismaClients: Record<string, string> =
+    compiled?.type === "success" ? compiled.nodeModules : {};
+
+  return await correctDecorator(
+    ctx,
+    pointer.value,
+    prismaClients,
+    templateFiles,
+  );
+}
+
+async function correctDecorator<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  result: IAutoBeRealizeDecoratorApplication.IProps,
+  prismaClients: Record<string, string>,
+  templateFiles: Record<string, string>,
+  life: number = 4,
+): Promise<IAutoBeRealizeDecoratorApplication.IProps> {
+  // Check Compile
+  const files = {
+    ...templateFiles,
+    ...prismaClients,
+    [`src/decorators/${result.decorator.name}.ts`]: result.decorator.code,
+    [`src/authentications/${result.provider.name}.ts`]: result.provider.code,
+    [`src/authentications/types/${result.decoratorType.name}.ts`]:
+      result.decoratorType.code,
+  };
+
+  const compiler: IAutoBeCompiler = await ctx.compiler();
+
+  const compiled = await compiler.typescript.compile({
+    files,
+  });
+
+  ctx.dispatch({
+    type: "realizeDecoratorValidate",
+    created_at: new Date().toISOString(),
+    result: compiled,
+    files,
+    step: ctx.state().test?.step ?? 0,
+  });
+
+  if (compiled.type === "success") {
+    return result;
+  } else if (compiled.type === "exception" || life === 0) {
+    return result;
+  }
+
+  const pointer: IPointer<IAutoBeRealizeDecoratorApplication.IProps | null> = {
+    value: null,
+  };
+
+  const agentica: MicroAgentica<Model> = new MicroAgentica({
+    model: ctx.model,
+    vendor: ctx.vendor,
+    config: {
+      ...(ctx.config ?? {}),
+      executor: {
+        describe: null,
+      },
+    },
+    histories: transformRealizeDecoratorCorrectHistories(
+      ctx,
+      result,
+      templateFiles,
+      compiled.diagnostics,
+    ),
+    controllers: [
+      createApplication({
+        model: ctx.model,
+        build: (next) => {
+          pointer.value = next;
+        },
+      }),
+    ],
+  });
+  enforceToolCall(agentica);
+
+  await agentica
+    .conversate("Please correct the decorator and the provider.")
+    .finally(() => {
+      const tokenUsage = agentica.getTokenUsage();
+      ctx.usage().record(tokenUsage, ["realize"]);
+    });
+
+  if (pointer.value === null) throw new Error("Failed to correct decorator.");
+
+  const correctedFiles: Record<string, string> = {
+    ...files,
+    [`src/decorators/${pointer.value.decorator.name}.ts`]:
+      pointer.value.decorator.code,
+    [`src/authentications/${pointer.value.provider.name}.ts`]:
+      pointer.value.provider.code,
+    [`src/authentications/types/${pointer.value.decoratorType.name}.ts`]:
+      pointer.value.decoratorType.code,
+  };
+
+  ctx.dispatch({
+    type: "realizeDecoratorCorrect",
+    created_at: new Date().toISOString(),
+    files: correctedFiles,
+    result: compiled,
+    step: ctx.state().test?.step ?? 0,
+  });
+
+  return await correctDecorator(
+    ctx,
+    pointer.value,
+    prismaClients,
+    templateFiles,
+    life - 1,
+  );
+}
+
+function createApplication<Model extends ILlmSchema.Model>(props: {
+  model: Model;
+  build: (next: IAutoBeRealizeDecoratorApplication.IProps) => void;
+}): IAgenticaController.IClass<Model> {
+  assertSchemaModel(props.model);
+
+  const application: ILlmApplication<Model> = collection[
+    props.model
+  ] as unknown as ILlmApplication<Model>;
+
+  return {
+    protocol: "class",
+    name: "Create Decorator",
+    application,
+    execute: {
+      createDecorator: (next) => {
+        props.build(next);
+      },
+    } satisfies IAutoBeRealizeDecoratorApplication,
+  };
+}
+
+const claude = typia.llm.application<
+  IAutoBeRealizeDecoratorApplication,
+  "claude",
+  {
+    reference: true;
+  }
+>();
+const collection = {
+  chatgpt: typia.llm.application<
+    IAutoBeRealizeDecoratorApplication,
+    "chatgpt",
+    { reference: true }
+  >(),
+  claude,
+  llama: claude,
+  deepseek: claude,
+  "3.1": claude,
+};

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

@@ -32,7 +32,7 @@ export namespace IAutoBeRealizeCoderApplication {
    *   logic.
    */
   export interface RealizeCoderOutput {
-    /** The name of the file to be generated (e.g., "user.create.ts") */
+    /** @ignore */
     filename: string;
 
     /**
@@ -68,9 +68,9 @@ export namespace IAutoBeRealizeCoderApplication {
      *
      * ⚠️ TypeScript-specific considerations:
      *
-     * - Do **not** use native `Date` objects directly; convert all dates with
-     *   `.toISOString()`
-     * - Use `string & tags.Format<'date-time'>` for all date/time typed fields
+     * - Do **not** use native `Date` objects directly; always convert all dates
+     *   to ISO strings with `.toISOString()` and brand as `string &
+     *   tags.Format<'date-time'>`. This rule applies throughout all phases.
      * - Prefer `satisfies` for DTO conformance instead of unsafe `as` casts
      * - Avoid weak typing such as `any`, `as any`, or `satisfies any`
      * - Use branded types (e.g., `tags.Format<'uuid'>`) and literal unions where
@@ -106,7 +106,7 @@ export namespace IAutoBeRealizeCoderApplication {
      *   - Using `?? undefined` to normalize nullable fields.
      *   - Applying correct relation handling (e.g., `connect` instead of direct
      *       foreign key assignment).
-     *   - Ensuring `Date` fields use `.toISOString()` and branded types.
+     *   - Ensuring all date fields use `.toISOString()` and proper branding.
      * - Include fallback or workaround plans if a direct fix is complex.
      * - If no error is present, simply omit this section.
      *
@@ -142,9 +142,10 @@ export namespace IAutoBeRealizeCoderApplication {
      *
      * - Avoid using the `any` type at all costs to ensure type safety.
      * - Do NOT assign native `Date` objects directly; always convert dates using
-     *   `.toISOString()` before assignment.
+     *   `.toISOString()` before assignment and apply proper branding.
      * - Maintain a single-function structure; avoid using classes.
      */
+    draft_without_date_type: string;
 
     /**
      * 🔍 Phase 2: Review code
@@ -172,9 +173,11 @@ export namespace IAutoBeRealizeCoderApplication {
      *
      * ✅ Must:
      *
-     * - Resolve all TypeScript errors without using `as any`
+     * - 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'>`)
+     *   tags.Format<'uuid'>`).
      */
     withCompilerFeedback?: string;
 
@@ -185,7 +188,7 @@ export namespace IAutoBeRealizeCoderApplication {
      *
      * - Passes strict type checking without errors.
      * - Uses only safe branding or literal type assertions.
-     * - Converts all Date values properly to ISO string format.
+     * - Converts all date values properly to ISO string format.
      * - Follows DTO structures using `satisfies`.
      * - Avoids any weak typing such as `any`, `as any`, or `satisfies any`.
      * - Uses only allowed imports (e.g., from `src/api/structures` and

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

@@ -0,0 +1,94 @@
+export interface IAutoBeRealizeDecoratorApplication {
+  createDecorator: (next: IAutoBeRealizeDecoratorApplication.IProps) => void;
+}
+
+export namespace IAutoBeRealizeDecoratorApplication {
+  export interface IProps {
+    /**
+     * Authentication Provider function configuration containing the function
+     * name and implementation code. The Provider handles JWT token
+     * verification, role validation, and database queries to authenticate
+     * users.
+     */
+    provider: IAutoBeRealizeDecoratorApplication.IProvider;
+
+    /**
+     * Authentication Decorator configuration containing the decorator name and
+     * implementation code. The Decorator integrates with NestJS parameter
+     * decorators to automatically inject authenticated user data into
+     * Controller methods.
+     */
+    decorator: IAutoBeRealizeDecoratorApplication.IDecorator;
+
+    /**
+     * Authentication Decorator Type configuration containing the decorator type
+     * name and implementation code. The Decorator Type is used to define the
+     * structure of the authenticated user data that will be injected into
+     * Controller methods when using the decorator. It serves as the TypeScript
+     * type for the parameter in Controller method signatures.
+     */
+    decoratorType: IAutoBeRealizeDecoratorApplication.IDecoratorType;
+  }
+
+  export interface IProvider {
+    /**
+     * The name of the authentication Provider function in {role}Authorize
+     * format (e.g., adminAuthorize, userAuthorize). This function will be
+     * called by the decorator to verify JWT tokens and return authenticated
+     * user information for the specified role.
+     */
+    name: string;
+
+    /**
+     * Complete TypeScript code for the authentication Provider function and its
+     * corresponding Payload interface. Must include: JWT token verification
+     * using jwtAuthorize function, role type checking against payload.type,
+     * database query using MyGlobal.prisma.{tableName} pattern to verify user
+     * existence, proper error handling with ForbiddenException and
+     * UnauthorizedException, and the Payload interface definition with id (UUID
+     * format) and type (role discriminator) fields using typia tags.
+     */
+    code: string;
+  }
+
+  export interface IDecorator {
+    /**
+     * The name of the Decorator to be generated in {Role}Auth format (e.g.,
+     * AdminAuth, UserAuth). This decorator will be used as a parameter
+     * decorator in Controller methods to automatically authenticate and
+     * authorize users for the specific role, injecting the authenticated user
+     * payload as a method parameter.
+     */
+    name: string;
+
+    /**
+     * Complete TypeScript code for the authentication Decorator implementation.
+     * Must include: SwaggerCustomizer integration to add bearer token security
+     * schema to API documentation, createParamDecorator implementation that
+     * calls the corresponding Provider function for authentication, Singleton
+     * pattern using tstl library for efficient decorator instance management,
+     * and proper TypeScript typing for the ParameterDecorator interface.
+     */
+    code: string;
+  }
+
+  export interface IDecoratorType {
+    /**
+     * The name of the Decorator to be generated in {Role}Auth format (e.g.,
+     * AdminAuth, UserAuth). This decorator will be used as a parameter
+     * decorator in Controller methods to automatically authenticate and
+     * authorize users for the specific role, injecting the authenticated user
+     * payload as a method parameter.
+     */
+    name: string;
+
+    /**
+     * The TypeScript code for the Payload type in {Role}Payload format (e.g.,
+     * AdminPayload, UserPayload). This interface defines the structure of the
+     * authenticated user data that will be injected into Controller methods
+     * when using the decorator. It serves as the TypeScript type for the
+     * parameter in Controller method signatures.
+     */
+    code: string;
+  }
+}