@autobe/agent 0.14.6 → 0.15.0

package/src/orchestrate/realize/orchestrateRealizeAuthorization.ts

@@ -5,8 +5,6 @@ import {
   IAutoBeTypeScriptCompileResult,
 } 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";
 
@@ -18,6 +16,7 @@ import { IAutoBeRealizeAuthorizationApplication } from "./structures/IAutoBeReal
 import { transformRealizeAuthorizationHistories } from "./transformRealizeAuthorization";
 import { transformRealizeAuthorizationCorrectHistories } from "./transformRealizeAuthorizationCorrectHistories";
 import { AuthorizationFileSystem } from "./utils/AuthorizationFileSystem";
+import { InternalFileSystem } from "./utils/InternalFileSystem";
 
 /**
  * 1. Create decorator and its parameters. and design the Authorization Provider.
@@ -36,34 +35,22 @@ export async function orchestrateRealizeAuthorization<
 
   let completed = 0;
 
-  const templateFiles = {
-    "src/MyGlobal.ts": await fs.readFile(
-      path.join(
-        __dirname,
-        "../../../../../internals/template/realize/src/MyGlobal.ts",
-      ),
-      "utf-8",
-    ),
-    [AuthorizationFileSystem.providerPath("jwtAuthorize")]: await fs.readFile(
-      path.join(
-        __dirname,
-        "../../../../../internals/template/realize/src/providers/jwtAuthorize.ts",
-      ),
-      "utf-8",
-    ),
-  };
+  const templateFiles = await (await ctx.compiler()).realize.getTemplate();
 
   ctx.dispatch({
     type: "realizeAuthorizationStart",
     step: ctx.state().test?.step ?? 0,
     created_at: new Date().toISOString(),
   });
+
   const authorizations: AutoBeRealizeAuthorization[] = await Promise.all(
     roles.map(async (role) => {
       const authorization: AutoBeRealizeAuthorization = await process(
         ctx,
         role,
-        templateFiles,
+        InternalFileSystem.DEFAULT.map((el) => ({
+          [el]: templateFiles[el],
+        })).reduce((acc, cur) => Object.assign(acc, cur), {}),
       );
       ctx.dispatch({
         type: "realizeAuthorizationWrite",

package/src/orchestrate/realize/orchestrateRealizeCoder.ts

@@ -9,10 +9,7 @@ import typia from "typia";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
-import {
-  randomBackoffRetry,
-  randomBackoffStrategy,
-} from "../../utils/backoffRetry";
+import { randomBackoffRetry } from "../../utils/backoffRetry";
 import { enforceToolCall } from "../../utils/enforceToolCall";
 import { getTestScenarioArtifacts } from "../test/compile/getTestScenarioArtifacts";
 import { IAutoBeTestScenarioArtifacts } from "../test/structures/IAutoBeTestScenarioArtifacts";
@@ -20,6 +17,7 @@ import { RealizePlannerOutput } from "./orchestrateRealizePlanner";
 import { IAutoBeRealizeCoderApplication } from "./structures/IAutoBeRealizeCoderApplication";
 import { FAILED } from "./structures/IAutoBeRealizeFailedSymbol";
 import { transformRealizeCoderHistories } from "./transformRealizeCoderHistories";
+import { RealizeFileSystem } from "./utils/ProviderFileSystem";
 import { replaceImportStatements } from "./utils/replaceImportStatements";
 
 /**
@@ -85,7 +83,6 @@ export const orchestrateRealizeCoder = async <Model extends ILlmSchema.Model>(
     vendor: ctx.vendor,
     config: {
       ...ctx.config,
-      backoffStrategy: randomBackoffStrategy,
       executor: {
         describe: null,
       },
@@ -138,7 +135,7 @@ export const orchestrateRealizeCoder = async <Model extends ILlmSchema.Model>(
 
   return {
     ...pointer.value,
-    filename: `src/providers/${props.functionName}.ts`,
+    filename: RealizeFileSystem.providerPath(props.functionName),
   };
 };
 

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

@@ -13,7 +13,7 @@ export namespace IAutoBeRealizeAuthorizationCorrectApplication {
      * Step 1: TypeScript compilation error analysis and diagnosis.
      *
      * AI identifies all compilation errors (type mismatches, imports, syntax)
-     * and categorizes them by component (provider/decorator/payload). Analyzes
+     * and categorizes them by component (providers/decorator/payload). Analyzes
      * error dependencies and determines fix priorities for systematic
      * resolution.
      */

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

@@ -4,42 +4,60 @@ import {
 } from "@autobe/interface";
 import { tags } from "typia";
 
-import { IAutoBeRealizeCoderApplication } from "./IAutoBeRealizeCoderApplication";
 import { FAILED } from "./IAutoBeRealizeFailedSymbol";
 
 export namespace IAutoBeRealizeCompile {
-  export interface Success {
-    type: "success";
+  type IBase<T extends "success" | "failed"> = {
+    type: T;
+  };
+
+  interface IOperation {
+    /**
+     * Operation: An object containing the function specification including the
+     * endpoint
+     */
     op: AutoBeOpenApi.IOperation;
-    result: Pick<
-      IAutoBeRealizeCoderApplication.RealizeCoderOutput,
-      "filename" | "implementationCode"
-    > & {
-      /** Function name */
-      name: string;
-    };
   }
 
-  export interface Fail {
-    type: "failed";
-    op: AutoBeOpenApi.IOperation;
+  interface SuccessResult {
+    /** The name of the file where the implementation will be written */
+    filename: string;
+    /** The generated implementation code for the function */
+    implementationCode: string;
+    /** Function name */
+    name: string;
+  }
+
+  export interface Success extends IBase<"success">, IOperation {
+    result: SuccessResult;
+  }
+
+  export interface Fail extends IBase<"failed">, IOperation {
     result: FAILED;
   }
 
-  export type FileContentMap = Record<
-    string,
-    {
-      result: "failed" | "success";
-      content: string;
-      role?: (string & tags.MinLength<1>) | null;
-      endpoint?: AutoBeOpenApi.IEndpoint;
-      location?: string;
-      name?: string;
-    }
-  >;
+  export interface FileContentMapEntry {
+    result: "failed" | "success";
+    content: string;
+    role?: (string & tags.MinLength<1>) | null;
+    endpoint?: AutoBeOpenApi.IEndpoint;
+    location?: string;
+    name?: string;
+  }
+
+  export type FileContentMap = Record<string, FileContentMapEntry>;
 
   export interface CompileDiagnostics {
+    /**
+     * Array containing all errors including previous attempts. Includes errors
+     * that have already been resolved. Used to preserve error context and
+     * identify recurring error patterns.
+     */
     total: IAutoBeTypeScriptCompileResult.IDiagnostic[];
+    /**
+     * Array containing errors from the most recent code compilation. These are
+     * the errors that need to be resolved in the current iteration.
+     */
     current: IAutoBeTypeScriptCompileResult.IDiagnostic[];
   }
 }

package/src/orchestrate/realize/transformRealizeCoderHistories.ts

@@ -101,12 +101,12 @@ export const transformRealizeCoderHistories = (
             `- Decorator implementation: decorators/${props.decoratorEvent.decorator.name}.ts`,
             `  - NestJS parameter decorator`,
             `  - When importing from providers folder, use: '../decorators/${props.decoratorEvent.decorator.name}'`,
-            `- Authentication provider: authentications/${props.decoratorEvent.provider.name}.ts`,
+            `- Authentication provider: decorators/${props.decoratorEvent.provider.name}.ts`,
             `  - Contains JWT validation, role checking, and authorization logic`,
-            `  - When importing from providers folder, use: '../authentications/${props.decoratorEvent.provider.name}'`,
-            `- Type definition: authentications/types/${props.decoratorEvent.payload.name}.ts`,
+            `  - 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: '../authentications/types/${props.decoratorEvent.payload.name}'`,
+            `  - When importing from providers folder, use: '../decorators/payload/${props.decoratorEvent.payload.name}'`,
           ].join("\n")
         : "",
     },

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

@@ -0,0 +1,12 @@
+export namespace InternalFileSystem {
+  /**
+   * Get template files for all of realize agents
+   *
+   * @returns Template file paths
+   */
+  export const DEFAULT = [
+    "src/providers/authorize/jwtAuthorize.ts",
+    "src/MyGlobal.ts",
+    "src/util/toISOStringSafe.ts",
+  ];
+}

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

@@ -0,0 +1,4 @@
+export namespace RealizeFileSystem {
+  export const providerPath = (filename: string): string =>
+    `src/providers/${filename}.ts`;
+}

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

@@ -38,7 +38,7 @@ export function replaceImportStatements<Model extends ILlmSchema.Model>(
     // Remove any existing decoratorType imports if LLM mistakenly added them
     if (decoratorType) {
       const decoratorTypeRegex = new RegExp(
-        `import\\s*{\\s*${decoratorType}\\s*}\\s*from\\s*["']\\.\\.\/authentications\/types\/${decoratorType}["']\\s*;?\\s*`,
+        `import\\s*{\\s*${decoratorType}\\s*}\\s*from\\s*["']\\.\\.\/decorators\/payload\/${decoratorType}["']\\s*;?\\s*`,
         "gm",
       );
       code = code.replace(decoratorTypeRegex, "");
@@ -56,7 +56,7 @@ export function replaceImportStatements<Model extends ILlmSchema.Model>(
     // Only add decoratorType import if it exists
     if (decoratorType) {
       imports.push(
-        `import { ${decoratorType} } from "../authentications/types/${decoratorType}"`,
+        `import { ${decoratorType} } from "../decorators/payload/${decoratorType}"`,
       );
     }
 

package/src/orchestrate/realize/writeCodeUntilCompilePassed.ts

@@ -5,15 +5,15 @@ import {
   IAutoBeTypeScriptCompileResult,
 } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
-import { readFile } from "fs/promises";
-import path from "path";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
+import { arrayToRecord } from "../../utils/arrayToRecord";
 import { pipe } from "./RealizePipe";
 import { orchestrateRealizeCoder } from "./orchestrateRealizeCoder";
 import { orchestrateRealizePlanner } from "./orchestrateRealizePlanner";
 import { IAutoBeRealizeCompile } from "./structures/IAutoBeRealizeCompile";
 import { FAILED } from "./structures/IAutoBeRealizeFailedSymbol";
+import { RealizeFileSystem } from "./utils/ProviderFileSystem";
 
 export async function writeCodeUntilCompilePassed<
   Model extends ILlmSchema.Model,
@@ -23,26 +23,20 @@ export async function writeCodeUntilCompilePassed<
   authorizations: AutoBeRealizeAuthorization[],
   retry: number,
 ): Promise<AutoBeRealizeFunction[]> {
-  const payloads = authorizations
-    .map((el) => {
-      return {
-        [el.payload.location]: el.payload.content,
-      };
-    })
-    .reduce<Record<string, string>>((acc, cur) => Object.assign(acc, cur), {});
-
-  const files = Object.entries(await ctx.files({ dbms: "postgres" }))
-    .filter(([key]) => {
-      return key.startsWith("src");
-    })
-    .reduce(
-      (acc, [filename, content]) => Object.assign(acc, { [filename]: content }),
-      {},
-    );
+  const payloads = arrayToRecord(
+    authorizations.map((el) => el.payload),
+    "location",
+    "content",
+  );
+
+  const files = arrayToRecord(
+    Object.entries(await ctx.files({ dbms: "postgres" })).filter(([key]) =>
+      key.startsWith("src"),
+    ),
+  );
 
-  const templateFiles = ["src/MyGlobal.ts", "src/util/toISOStringSafe.ts"];
   const entireCodes: IAutoBeRealizeCompile.FileContentMap = {
-    ...(await loadTemplateFiles(templateFiles)),
+    ...(await loadTemplateFiles(ctx)),
   };
 
   let diagnostics: IAutoBeRealizeCompile.CompileDiagnostics = {
@@ -91,16 +85,12 @@ export async function writeCodeUntilCompilePassed<
         ...payloads,
         ...files,
         ...nodeModules,
-        ...Object.entries(entireCodes)
-          .map(([filename, { content }]) => {
-            return {
-              [filename]: content,
-            };
-          })
-          .reduce<Record<string, string>>(
-            (acc, cur) => Object.assign(acc, cur),
-            {},
-          ),
+        ...arrayToRecord(
+          Object.entries(entireCodes).map(([filename, { content }]) => [
+            filename,
+            content,
+          ]),
+        ),
       },
     });
 
@@ -121,35 +111,33 @@ export async function writeCodeUntilCompilePassed<
     }
   }
 
-  return Object.entries(entireCodes)
-    .filter(([filename]) => filename.startsWith("src/providers")) // filter only provider files
-    .map(([filename, value]) => {
-      return {
-        filename,
-        content: value.content,
-        endpoint: value.endpoint!,
-        location: value.location!,
-        name: value.name!,
-        role: value.role!,
-      };
-    });
+  return (
+    Object.entries(entireCodes)
+      // .filter(([filename]) => filename.startsWith("src/providers")) // filter only provider files
+      .map(([filename, value]) => {
+        return {
+          filename,
+          content: value.content,
+          endpoint: value.endpoint!,
+          location: value.location!,
+          name: value.name!,
+          role: value.role!,
+        };
+      })
+  );
 }
 
-async function loadTemplateFiles(
-  templateFiles: string[],
+async function loadTemplateFiles<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
 ): Promise<IAutoBeRealizeCompile.FileContentMap> {
-  const templateBasePath = path.join(
-    __dirname,
-    "../../../../../internals/template/realize",
-  );
+  const templateFiles = await (await ctx.compiler()).realize.getTemplate();
+  const targets = ["src/MyGlobal.ts", "src/util/toISOStringSafe.ts"];
 
   const result: IAutoBeRealizeCompile.FileContentMap = {};
 
-  for (const filePath of templateFiles) {
+  for (const filePath of targets) {
     result[filePath] = {
-      content: await readFile(path.join(templateBasePath, filePath), {
-        encoding: "utf-8",
-      }),
+      content: templateFiles[filePath],
       result: "success",
       location: filePath,
       role: null,
@@ -171,7 +159,7 @@ async function process<Model extends ILlmSchema.Model>(
     op,
     (op) => orchestrateRealizePlanner(ctx, op, decorator),
     async (p) => {
-      const filename = `src/providers/${p.functionName}.ts` as const;
+      const filename = RealizeFileSystem.providerPath(p.functionName);
       const t = diagnostics.total.filter((el) => el.file === filename);
 
       const d = diagnostics.current.filter((el) => el.file === filename);
@@ -204,6 +192,16 @@ async function process<Model extends ILlmSchema.Model>(
   return { type: "success", op: op, result } as const;
 }
 
+/**
+ * Determines whether an operation should be processed in the current iteration.
+ * In the initial case (no errors), all operations are processed. When errors
+ * exist, only operations with compilation errors are targeted for reprocessing
+ * in the next iteration.
+ *
+ * @param op - The operation to check
+ * @param currentDiagnostics - Current compilation errors
+ * @returns True if the operation should be processed
+ */
 function shouldProcessOperation(
   op: AutoBeOpenApi.IOperation,
   currentDiagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[],
@@ -219,6 +217,14 @@ function shouldProcessOperation(
   );
 }
 
+/**
+ * Generates a provider filename for an operation. Converts the operation's HTTP
+ * method and path into a valid TypeScript filename. The filename serves as both
+ * the function name and the file identifier.
+ *
+ * @param op - The operation to generate a filename for
+ * @returns The generated provider filename with path
+ */
 function generateProviderFilename(op: AutoBeOpenApi.IOperation): string {
   return `src/providers/${op.method}_${op.path
     .replaceAll("/", "_")

package/src/orchestrate/test/compile/getTestScenarioArtifacts.ts

@@ -52,6 +52,7 @@ function filterDocument(
       ),
   );
   const components: AutoBeOpenApi.IComponents = {
+    authorization: document.components.authorization,
     schemas: {},
   };
   const visit = (typeName: string) => {

package/src/orchestrate/test/orchestrateTestScenario.ts

@@ -150,9 +150,11 @@ const execute = async <Model extends ILlmSchema.Model>(
     ctx.usage().record(tokenUsage, ["test"]);
   });
   if (pointer.value.length === 0) {
-    throw new Error("Failed to create test plans.");
+    console.error("Failed to create test plans. No function called.");
+    return [];
+    // @todo
+    // throw new Error("Failed to create test plans.");
   }
-
   return pointer.value;
 };
 

package/src/utils/arrayToRecord.ts

@@ -0,0 +1,49 @@
+/**
+ * Converts an array of key-value pairs (entries) into a Record.
+ *
+ * @param entries - Array of [key, value] tuples
+ * @returns Record object from the entries
+ */
+export function arrayToRecord<V>(
+  entries: Array<[string, V]>,
+): Record<string, V>;
+
+/**
+ * Converts an array of objects into a Record using specified key and value
+ * properties.
+ *
+ * @param items - Array of items to convert
+ * @param keyProp - Property name to use as the key
+ * @param valueProp - Property name to use as the value
+ * @returns Record object with the extracted key-value pairs
+ */
+export function arrayToRecord<T, K extends keyof T, V extends keyof T>(
+  items: T[],
+  keyProp: K,
+  valueProp: V,
+): Record<string, T[V]>;
+
+export function arrayToRecord<T, K extends keyof T, V extends keyof T>(
+  items: T[] | Array<[string, any]>,
+  keyProp?: K,
+  valueProp?: V,
+): Record<string, any> {
+  // Handle entries format [string, value][]
+  if (items.length > 0 && Array.isArray(items[0]) && items[0].length === 2) {
+    return (items as Array<[string, any]>).reduce(
+      (acc, [key, value]) => Object.assign(acc, { [key]: value }),
+      {},
+    );
+  }
+
+  // Handle object array format with key and value properties
+  if (keyProp !== undefined && valueProp !== undefined) {
+    return (items as T[])
+      .map((item) => ({
+        [String(item[keyProp])]: item[valueProp],
+      }))
+      .reduce((acc, cur) => Object.assign(acc, cur), {});
+  }
+
+  throw new Error("Invalid arguments for arrayToRecord");
+}

package/src/utils/backoffRetry.ts

@@ -57,7 +57,6 @@ export function randomBackoffStrategy(props: {
   count: number;
   error: unknown;
 }): number {
-  console.log("randomBackoffStrategy");
   const { count, error } = props;
   if (count > 5) {
     throw error;

package/lib/orchestrate/interface/OpenApiEndpointComparator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"OpenApiEndpointComparator.js","sourceRoot":"","sources":["../../../src/orchestrate/interface/OpenApiEndpointComparator.ts"],"names":[],"mappings":";;;AACA,+BAA4B;AAE5B,IAAiB,yBAAyB,CAWzC;AAXD,WAAiB,yBAAyB;IACxC,SAAgB,QAAQ,CAAC,CAA0B;QACjD,OAAO,IAAA,WAAI,EAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC;IAChC,CAAC;IAFe,kCAAQ,WAEvB,CAAA;IAED,SAAgB,MAAM,CACpB,CAA0B,EAC1B,CAA0B;QAE1B,OAAO,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM,CAAC;IACpD,CAAC;IALe,gCAAM,SAKrB,CAAA;AACH,CAAC,EAXgB,yBAAyB,yCAAzB,yBAAyB,QAWzC"}

package/lib/orchestrate/interface/orchestrateInterfaceComponents.d.ts

@@ -1,4 +0,0 @@
-import { AutoBeOpenApi } from "@autobe/interface";
-import { ILlmSchema } from "@samchon/openapi";
-import { AutoBeContext } from "../../context/AutoBeContext";
-export declare function orchestrateInterfaceComponents<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, operations: AutoBeOpenApi.IOperation[], capacity?: number): Promise<AutoBeOpenApi.IComponents>;