@autobe/agent 0.15.1 → 0.16.0

package/src/orchestrate/realize/transformRealizeAuthorizationCorrectHistories.ts

@@ -80,6 +80,15 @@ export const transformRealizeAuthorizationCorrectHistories = (
         "```json",
         JSON.stringify(diagnostics, null, 2),
         "```",
+        "## Component Naming Convention",
+        "",
+        "If the name of the component is not correct, please correct it.",
+        "",
+        "Please follow this naming convention for the authorization components:",
+        "",
+        `- Provider Name: ${auth.role.toLowerCase()}Authorize (e.g. ${auth.role.toLowerCase()}Authorize)`,
+        `- Decorator Name: ${auth.role.charAt(0).toUpperCase() + auth.role.slice(1).toLowerCase()}Auth (e.g. ${auth.role.charAt(0).toUpperCase() + auth.role.slice(1).toLowerCase()}Auth)`,
+        `- Payload Name: ${auth.role.charAt(0).toUpperCase() + auth.role.slice(1).toLowerCase()}Payload (e.g. ${auth.role.charAt(0).toUpperCase() + auth.role.slice(1).toLowerCase()}Payload)`,
       ].join("\n"),
     },
   ];

package/src/orchestrate/realize/transformRealizeCoderHistories.ts

@@ -1,21 +1,57 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
-import { IAutoBeTypeScriptCompileResult } from "@autobe/interface";
+import {
+  AutoBeRealizeAuthorization,
+  IAutoBeTypeScriptCompileResult,
+} from "@autobe/interface";
 import { v4 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
 import { AutoBeState } from "../../context/AutoBeState";
 import { IAutoBeTestScenarioArtifacts } from "../test/structures/IAutoBeTestScenarioArtifacts";
 import { RealizePlannerOutput } from "./orchestrateRealizePlanner";
+import { IAutoBeRealizeCompile } from "./structures/IAutoBeRealizeCompile";
 
 export const transformRealizeCoderHistories = (
   state: AutoBeState,
+  previousCodes: IAutoBeRealizeCompile.Success[],
   props: RealizePlannerOutput,
   artifacts: IAutoBeTestScenarioArtifacts,
   previous: string | null,
   diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[],
+  authorization?: AutoBeRealizeAuthorization,
 ): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
 > => {
+  const [operation] = artifacts.document.operations;
+
+  const propsFields: string[] = [];
+
+  // payload 추가
+  if (authorization && operation.authorizationRole) {
+    propsFields.push(
+      `${operation.authorizationRole}: ${authorization.payload.name};`,
+    );
+  }
+
+  // parameters 추가
+  operation.parameters.forEach((parameter) => {
+    const format =
+      "format" in parameter.schema
+        ? ` & tags.Format<'${parameter.schema.format}'>`
+        : "";
+    propsFields.push(`${parameter.name}: ${parameter.schema.type}${format};`);
+  });
+
+  // body 추가
+  if (operation.requestBody?.typeName) {
+    propsFields.push(`body: ${operation.requestBody.typeName};`);
+  }
+
+  const input =
+    propsFields.length > 0
+      ? `props: {\n${propsFields.map((field) => `  ${field}`).join("\n")}\n}`
+      : `// No props parameter needed - function should have no parameters`;
+
   if (state.analyze === null)
     return [
       {
@@ -91,25 +127,6 @@ export const transformRealizeCoderHistories = (
       type: "systemMessage",
       text: AutoBeSystemPromptConstant.REALIZE_CODER_TOTAL,
     },
-    {
-      id: v4(),
-      created_at: new Date().toISOString(),
-      type: "systemMessage",
-      text: props.decoratorEvent
-        ? [
-            "Decorator-related files are already generated at the following locations:",
-            `- Decorator implementation: decorators/${props.decoratorEvent.decorator.name}.ts`,
-            `  - NestJS parameter decorator`,
-            `  - When importing from providers folder, use: '../decorators/${props.decoratorEvent.decorator.name}'`,
-            `- Authentication provider: decorators/${props.decoratorEvent.provider.name}.ts`,
-            `  - Contains JWT validation, role checking, and authorization logic`,
-            `  - When importing from providers folder, use: '../decorators/${props.decoratorEvent.provider.name}'`,
-            `- Type definition: decorators/payload/${props.decoratorEvent.payload.name}.ts`,
-            `  - TypeScript interface for authenticated user payload`,
-            `  - When importing from providers folder, use: '../decorators/payload/${props.decoratorEvent.payload.name}'`,
-          ].join("\n")
-        : "",
-    },
     {
       id: v4(),
       created_at: new Date().toISOString(),
@@ -119,11 +136,44 @@ export const transformRealizeCoderHistories = (
         JSON.stringify(state.prisma.schemas),
       )
         .replaceAll(`{artifacts_sdk}`, JSON.stringify(artifacts.sdk))
-        .replaceAll(`{artifacts_dto}`, JSON.stringify(artifacts.dto)),
-      // .replaceAll(`{artifacts_document}`, JSON.stringify(artifacts.document)),
+        .replaceAll(`{artifacts_dto}`, JSON.stringify(artifacts.dto))
+        .replaceAll(`{input}`, input),
     },
     ...(previous !== null
       ? [
+          {
+            id: v4(),
+            created_at: new Date().toISOString(),
+            type: "assistantMessage",
+            text: [
+              "These values contain previously generated code and thought flow.",
+              "All of these codes are failed compilation values.",
+              previousCodes.length >= 2
+                ? "🚨 CRITICAL: You have already failed " +
+                  previousCodes.length +
+                  " times. The current approach is FUNDAMENTALLY WRONG!"
+                : "Please refer to the code for writing a new code.",
+              previousCodes.length >= 2
+                ? [
+                    "",
+                    "After multiple failures, you MUST make AGGRESSIVE changes:",
+                    "1. COMPLETELY REWRITE the problematic parts - don't just tweak",
+                    "2. Try a DIFFERENT algorithm or approach entirely",
+                    "3. Question ALL your assumptions about the requirements",
+                    "4. Consider alternative Prisma patterns or query structures",
+                    "5. The error might be in your fundamental understanding - rethink everything",
+                  ].join("\n")
+                : "",
+              "",
+              "```json",
+              JSON.stringify(
+                previousCodes.map((c) => c.result.implementationCode),
+              ),
+              "```",
+            ]
+              .filter(Boolean)
+              .join("\n"),
+          } as const,
           {
             id: v4(),
             created_at: new Date().toISOString(),
@@ -131,9 +181,7 @@ export const transformRealizeCoderHistories = (
             text: AutoBeSystemPromptConstant.REALIZE_CODER_DIAGNOSTICS.replaceAll(
               `{code}`,
               previous,
-            )
-              // .replaceAll("{total_diagnostics}", JSON.stringify(total))
-              .replaceAll("{current_diagnostics}", JSON.stringify(diagnostics)),
+            ).replaceAll("{current_diagnostics}", JSON.stringify(diagnostics)),
           } as const,
           {
             id: v4(),

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

@@ -0,0 +1,9 @@
+export namespace AutoBeRealizeAuthorizationFileSystem {
+  export const getDecoratorPath = (name: string) => `src/decorators/${name}.ts`;
+
+  export const getPayloadPath = (name: string) =>
+    `src/decorators/payload/${name}.ts`;
+
+  export const getProviderPath = (name: string) =>
+    `src/providers/authorize/${name}.ts`;
+}

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

@@ -0,0 +1,64 @@
+export namespace AutoBeRealizeAuthorizationReplaceImport {
+  export function replaceProviderImport(role: string, content: string): string {
+    let updatedContent = content;
+
+    const roleCapitalized =
+      role.charAt(0).toUpperCase() + role.slice(1).toLowerCase();
+
+    const nestjsCommonPattern =
+      /import\s+{\s*[^}]*\s*}\s+from\s+"@nestjs\/common";/g;
+    const nestjsCommonReplacement =
+      'import { ForbiddenException, UnauthorizedException } from "@nestjs/common";';
+
+    const myGlobalPattern = /import\s+{\s*MyGlobal\s*}\s+from\s+[^;]+;/g;
+    const myGlobalReplacement = 'import { MyGlobal } from "../../MyGlobal";';
+
+    const jwtAuthorizePattern =
+      /import\s+{\s*jwtAuthorize\s*}\s+from\s+[^;]+;/g;
+    const jwtAuthorizeReplacement =
+      'import { jwtAuthorize } from "./jwtAuthorize";';
+
+    const payloadPattern = /import\s+{\s*\w*Payload\s*}\s+from\s+[^;]+;/g;
+    const payloadReplacement = `import { ${roleCapitalized}Payload } from "../../decorators/payload/${roleCapitalized}Payload";`;
+
+    // 각 패턴을 순차적으로 적용
+    updatedContent = updatedContent.replace(
+      nestjsCommonPattern,
+      nestjsCommonReplacement,
+    );
+    updatedContent = updatedContent.replace(
+      myGlobalPattern,
+      myGlobalReplacement,
+    );
+    updatedContent = updatedContent.replace(
+      jwtAuthorizePattern,
+      jwtAuthorizeReplacement,
+    );
+    updatedContent = updatedContent.replace(payloadPattern, payloadReplacement);
+
+    return updatedContent;
+  }
+
+  export function replaceDecoratorImport(
+    role: string,
+    content: string,
+  ): string {
+    let updatedContent = content;
+
+    const roleLowercase = role.toLowerCase();
+
+    // ~Authorize로 끝나는 import 구문을 특정 경로로 변경하는 정규표현식
+    const authorizePattern = /import\s+{\s*\w*Authorize\s*}\s+from\s+[^;]+;/g;
+
+    // role을 기반으로 동적으로 replacement 생성
+    const authorizeReplacement = `import { ${roleLowercase}Authorize } from "../providers/authorize/${roleLowercase}Authorize";`;
+
+    // 패턴 적용
+    updatedContent = updatedContent.replace(
+      authorizePattern,
+      authorizeReplacement,
+    );
+
+    return updatedContent;
+  }
+}

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

@@ -2,11 +2,24 @@ import { IAutoBeCompiler } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
 
 import { AutoBeContext } from "../../../context/AutoBeContext";
+import { IAutoBeTestScenarioArtifacts } from "../../test/structures/IAutoBeTestScenarioArtifacts";
 
 export function replaceImportStatements<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
 ) {
-  return async function (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]!,
+        ),
+      ),
+    );
+
     const compiler: IAutoBeCompiler = await ctx.compiler();
     code = await compiler.typescript.beautify(code);
     // Remove existing import statements using flexible regex patterns
@@ -35,10 +48,32 @@ export function replaceImportStatements<Model extends ILlmSchema.Model>(
         "",
       );
 
+    // 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 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 decoratorType imports if LLM mistakenly added them
     if (decoratorType) {
       const decoratorTypeRegex = new RegExp(
-        `import\\s*{\\s*${decoratorType}\\s*}\\s*from\\s*["']\\.\\.\/decorators\/payload\/${decoratorType}["']\\s*;?\\s*`,
+        `import\\s*(?:type\\s*)?{\\s*${decoratorType}\\s*}\\s*from\\s*["']\\.\\.\/decorators\/payload\/${decoratorType}["']\\s*;?\\s*`,
         "gm",
       );
       code = code.replace(decoratorTypeRegex, "");
@@ -51,6 +86,10 @@ export function replaceImportStatements<Model extends ILlmSchema.Model>(
       '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}";`,
+      ),
     ];
 
     // Only add decoratorType import if it exists