@autobe/agent 0.30.0-dev.20260315 → 0.30.1

package/src/orchestrate/test/orchestrateTestGenerate.ts

@@ -1,121 +1,121 @@
-import {
-  AutoBeEventSource,
-  AutoBeOpenApi,
-  AutoBeProgressEventBase,
-  AutoBeTestGenerateFunction,
-  AutoBeTestPrepareFunction,
-} from "@autobe/interface";
-import typia, { ILlmApplication, ILlmController, IValidation } from "typia";
-
-import { AutoBeContext } from "../../context/AutoBeContext";
-import { orchestrateTestCorrectCasting } from "./internal/orchestrateTestCorrectCasting";
-import { orchestrateTestCorrectOverall } from "./internal/orchestrateTestCorrectOverall";
-// import { orchestrateTestCorrectRequest } from "./internal/orchestrateTestCorrectRequest";
-import { orchestrateTestGenerateWrite } from "./orchestrateTestGenerateWrite";
-import { AutoBeTestGenerateProgrammer } from "./programmers/AutoBeTestGenerateProgrammer";
-import { IAutoBeTestCorrectOverallApplication } from "./structures/IAutoBeTestCorrectOverallApplication";
-import { IAutoBeTestGenerateProcedure } from "./structures/IAutoBeTestGenerateProcedure";
-
-export async function orchestrateTestGenerate(
-  ctx: AutoBeContext,
-  props: {
-    instruction: string;
-    document: AutoBeOpenApi.IDocument;
-    prepares: AutoBeTestPrepareFunction[];
-    writeProgress: AutoBeProgressEventBase;
-    validateProgress: AutoBeProgressEventBase;
-  },
-): Promise<AutoBeTestGenerateFunction[]> {
-  const compile = async (procedure: IAutoBeTestGenerateProcedure) =>
-    AutoBeTestGenerateProgrammer.compile({
-      compiler: await ctx.compiler(),
-      step: ctx.state().analyze?.step ?? 0,
-      progress: props.validateProgress,
-      procedure,
-    });
-  const replaceImportStatements = async (
-    procedure: IAutoBeTestGenerateProcedure,
-  ) =>
-    AutoBeTestGenerateProgrammer.replaceImportStatements({
-      compiler: await ctx.compiler(),
-      artifacts: procedure.artifacts,
-      prepare: procedure.prepare,
-      location: procedure.function.location,
-      content: procedure.function.content,
-    });
-
-  let procedures: IAutoBeTestGenerateProcedure[] =
-    await orchestrateTestGenerateWrite(ctx, {
-      instruction: props.instruction,
-      document: props.document,
-      prepares: props.prepares,
-      progress: props.writeProgress,
-    });
-  props.validateProgress.total += procedures.length;
-
-  procedures = await orchestrateTestCorrectCasting(ctx, {
-    programmer: {
-      compile,
-      replaceImportStatements,
-      asynchronous: true,
-    },
-    procedures,
-    progress: props.validateProgress,
-  });
-  procedures = await orchestrateTestCorrectOverall(ctx, {
-    programmer: {
-      compile,
-      replaceImportStatements,
-      controller: (next) => createCorrectOverallController(next),
-    },
-    instruction: props.instruction,
-    progress: props.validateProgress,
-    procedures,
-    discard: false,
-  });
-  return procedures.map((p) => p.function);
-}
-
-function createCorrectOverallController(props: {
-  procedure: IAutoBeTestGenerateProcedure;
-  build: (next: IAutoBeTestCorrectOverallApplication.IProps) => void;
-}): ILlmController<IAutoBeTestCorrectOverallApplication> {
-  const validate: Validator = (input) => {
-    const result: IValidation<IAutoBeTestCorrectOverallApplication.IProps> =
-      typia.validate<IAutoBeTestCorrectOverallApplication.IProps>(input);
-    if (result.success === false) return result;
-    const errors: IValidation.IError[] = AutoBeTestGenerateProgrammer.validate({
-      procedure: props.procedure,
-      draft: result.data.draft,
-      revise: result.data.revise,
-    });
-    return errors.length
-      ? {
-          success: false,
-          errors,
-          data: result.data,
-        }
-      : result;
-  };
-
-  const application: ILlmApplication =
-    typia.llm.application<IAutoBeTestCorrectOverallApplication>({
-      validate: {
-        rewrite: validate,
-      },
-    });
-  return {
-    protocol: "class",
-    name: "testCorrect" satisfies AutoBeEventSource,
-    application,
-    execute: {
-      rewrite: (v) => {
-        props.build(v);
-      },
-    } satisfies IAutoBeTestCorrectOverallApplication,
-  };
-}
-
-type Validator = (
-  input: unknown,
-) => IValidation<IAutoBeTestCorrectOverallApplication.IProps>;
+import {
+  AutoBeEventSource,
+  AutoBeOpenApi,
+  AutoBeProgressEventBase,
+  AutoBeTestGenerateFunction,
+  AutoBeTestPrepareFunction,
+} from "@autobe/interface";
+import typia, { ILlmApplication, ILlmController, IValidation } from "typia";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { orchestrateTestCorrectCasting } from "./internal/orchestrateTestCorrectCasting";
+import { orchestrateTestCorrectOverall } from "./internal/orchestrateTestCorrectOverall";
+// import { orchestrateTestCorrectRequest } from "./internal/orchestrateTestCorrectRequest";
+import { orchestrateTestGenerateWrite } from "./orchestrateTestGenerateWrite";
+import { AutoBeTestGenerateProgrammer } from "./programmers/AutoBeTestGenerateProgrammer";
+import { IAutoBeTestCorrectOverallApplication } from "./structures/IAutoBeTestCorrectOverallApplication";
+import { IAutoBeTestGenerateProcedure } from "./structures/IAutoBeTestGenerateProcedure";
+
+export async function orchestrateTestGenerate(
+  ctx: AutoBeContext,
+  props: {
+    instruction: string;
+    document: AutoBeOpenApi.IDocument;
+    prepares: AutoBeTestPrepareFunction[];
+    writeProgress: AutoBeProgressEventBase;
+    validateProgress: AutoBeProgressEventBase;
+  },
+): Promise<AutoBeTestGenerateFunction[]> {
+  const compile = async (procedure: IAutoBeTestGenerateProcedure) =>
+    AutoBeTestGenerateProgrammer.compile({
+      compiler: await ctx.compiler(),
+      step: ctx.state().analyze?.step ?? 0,
+      progress: props.validateProgress,
+      procedure,
+    });
+  const replaceImportStatements = async (
+    procedure: IAutoBeTestGenerateProcedure,
+  ) =>
+    AutoBeTestGenerateProgrammer.replaceImportStatements({
+      compiler: await ctx.compiler(),
+      artifacts: procedure.artifacts,
+      prepare: procedure.prepare,
+      location: procedure.function.location,
+      content: procedure.function.content,
+    });
+
+  let procedures: IAutoBeTestGenerateProcedure[] =
+    await orchestrateTestGenerateWrite(ctx, {
+      instruction: props.instruction,
+      document: props.document,
+      prepares: props.prepares,
+      progress: props.writeProgress,
+    });
+  props.validateProgress.total += procedures.length;
+
+  procedures = await orchestrateTestCorrectCasting(ctx, {
+    programmer: {
+      compile,
+      replaceImportStatements,
+      asynchronous: true,
+    },
+    procedures,
+    progress: props.validateProgress,
+  });
+  procedures = await orchestrateTestCorrectOverall(ctx, {
+    programmer: {
+      compile,
+      replaceImportStatements,
+      controller: (next) => createCorrectOverallController(next),
+    },
+    instruction: props.instruction,
+    progress: props.validateProgress,
+    procedures,
+    discard: false,
+  });
+  return procedures.map((p) => p.function);
+}
+
+function createCorrectOverallController(props: {
+  procedure: IAutoBeTestGenerateProcedure;
+  build: (next: IAutoBeTestCorrectOverallApplication.IProps) => void;
+}): ILlmController<IAutoBeTestCorrectOverallApplication> {
+  const validate: Validator = (input) => {
+    const result: IValidation<IAutoBeTestCorrectOverallApplication.IProps> =
+      typia.validate<IAutoBeTestCorrectOverallApplication.IProps>(input);
+    if (result.success === false) return result;
+    const errors: IValidation.IError[] = AutoBeTestGenerateProgrammer.validate({
+      procedure: props.procedure,
+      draft: result.data.draft,
+      revise: result.data.revise,
+    });
+    return errors.length
+      ? {
+          success: false,
+          errors,
+          data: result.data,
+        }
+      : result;
+  };
+
+  const application: ILlmApplication =
+    typia.llm.application<IAutoBeTestCorrectOverallApplication>({
+      validate: {
+        rewrite: validate,
+      },
+    });
+  return {
+    protocol: "class",
+    name: "testCorrect" satisfies AutoBeEventSource,
+    application,
+    execute: {
+      rewrite: (v) => {
+        props.build(v);
+      },
+    } satisfies IAutoBeTestCorrectOverallApplication,
+  };
+}
+
+type Validator = (
+  input: unknown,
+) => IValidation<IAutoBeTestCorrectOverallApplication.IProps>;

package/src/orchestrate/test/orchestrateTestGenerateWrite.ts

@@ -1,211 +1,211 @@
-import { IAgenticaController } from "@agentica/core";
-import {
-  AutoBeOpenApi,
-  AutoBeProgressEventBase,
-  AutoBeTestPrepareFunction,
-  AutoBeTestWriteEvent,
-} from "@autobe/interface";
-import { AutoBeOpenApiTypeChecker } from "@autobe/utils";
-import { IPointer } from "tstl";
-import typia, { ILlmApplication, IValidation } from "typia";
-import { v7 } from "uuid";
-
-import { AutoBeContext } from "../../context/AutoBeContext";
-import { executeCachedBatch } from "../../utils/executeCachedBatch";
-import { forceRetry } from "../../utils/forceRetry";
-import { validateEmptyCode } from "../../utils/validateEmptyCode";
-import { getTestArtifacts } from "./compile/getTestArtifacts";
-import { transformTestGenerateWriteHistory } from "./histories/transformTestGenerationWriteHistory";
-import { AutoBeTestGenerateProgrammer } from "./programmers/AutoBeTestGenerateProgrammer";
-import { IAutoBeTestArtifacts } from "./structures/IAutoBeTestArtifacts";
-import { IAutoBeTestGenerateProcedure } from "./structures/IAutoBeTestGenerateProcedure";
-import { IAutoBeTestGenerationWriteApplication } from "./structures/IAutoBeTestGenerationWriteApplication";
-
-export const orchestrateTestGenerateWrite = async (
-  ctx: AutoBeContext,
-  props: {
-    instruction: string;
-    document: AutoBeOpenApi.IDocument;
-    prepares: AutoBeTestPrepareFunction[];
-    progress: AutoBeProgressEventBase;
-  },
-): Promise<IAutoBeTestGenerateProcedure[]> => {
-  const result: Array<IAutoBeTestGenerateProcedure | null> =
-    await executeCachedBatch(
-      ctx,
-      props.document.operations.map((operation) => async (promptCacheKey) => {
-        if (operation.requestBody === null) return null;
-        else if (operation.requestBody.typeName.endsWith(".ICreate") === false)
-          return null;
-        else if (
-          props.document.components.schemas[operation.requestBody.typeName] ===
-          undefined
-        )
-          return null;
-        else if (
-          AutoBeOpenApiTypeChecker.isObject(
-            props.document.components.schemas[operation.requestBody.typeName],
-          ) === false
-        )
-          return null;
-
-        const prepareFunction: AutoBeTestPrepareFunction | undefined =
-          props.prepares.find(
-            (pf) => pf.typeName === operation.requestBody?.typeName,
-          );
-        if (prepareFunction === undefined) return null;
-
-        const artifacts: IAutoBeTestArtifacts = await getTestArtifacts(ctx, {
-          endpoint: {
-            path: operation.path,
-            method: operation.method,
-          },
-        });
-
-        try {
-          return await forceRetry(async () => {
-            const event: AutoBeTestWriteEvent = await process(ctx, {
-              prepare: prepareFunction,
-              artifacts,
-              operation,
-              progress: props.progress,
-              promptCacheKey,
-              instruction: props.instruction,
-            });
-            if (event.function.type !== "generate") return null;
-
-            ctx.dispatch(event);
-            return {
-              type: "generate",
-              prepare: prepareFunction,
-              artifacts,
-              function: event.function,
-              operation,
-            } satisfies IAutoBeTestGenerateProcedure;
-          });
-        } catch {
-          return null;
-        }
-      }),
-    );
-  return result.filter((r) => r !== null);
-};
-
-async function process(
-  ctx: AutoBeContext,
-  props: {
-    prepare: AutoBeTestPrepareFunction;
-    artifacts: IAutoBeTestArtifacts;
-    operation: AutoBeOpenApi.IOperation;
-    progress: AutoBeProgressEventBase;
-    promptCacheKey: string;
-    instruction: string;
-  },
-): Promise<AutoBeTestWriteEvent> {
-  const functionName: string = AutoBeTestGenerateProgrammer.getFunctionName(
-    props.operation,
-  );
-  const pointer: IPointer<IAutoBeTestGenerationWriteApplication.IProps | null> =
-    {
-      value: null,
-    };
-  const { metric, tokenUsage } = await ctx.conversate({
-    source: "testWrite",
-    controller: createController({
-      functionName,
-      build: (next) => {
-        pointer.value = next;
-      },
-    }),
-    enforceFunctionCall: true,
-    promptCacheKey: props.promptCacheKey,
-    ...(await transformTestGenerateWriteHistory(ctx, {
-      instruction: props.instruction,
-      prepare: props.prepare,
-      operation: props.operation,
-      artifacts: props.artifacts,
-    })),
-  });
-
-  if (pointer.value === null) {
-    ++props.progress.completed;
-    throw new Error("Failed to create generation function.");
-  }
-
-  const location: string = `test/generate/${functionName}.ts`;
-  return {
-    type: "testWrite",
-    id: v7(),
-    created_at: new Date().toISOString(),
-    function: {
-      type: "generate",
-      endpoint: {
-        method: props.operation.method,
-        path: props.operation.path,
-      },
-      actor: props.operation.authorizationActor,
-      location,
-      name: functionName,
-      content: await AutoBeTestGenerateProgrammer.replaceImportStatements({
-        compiler: await ctx.compiler(),
-        artifacts: props.artifacts,
-        prepare: props.prepare,
-        location,
-        content: pointer.value.revise.final ?? pointer.value.draft,
-      }),
-    },
-    metric,
-    tokenUsage,
-    completed: ++props.progress.completed,
-    total: props.progress.total,
-    step: ctx.state().test?.step ?? 0,
-  } satisfies AutoBeTestWriteEvent;
-}
-
-function createController(props: {
-  functionName: string;
-  build: (next: IAutoBeTestGenerationWriteApplication.IProps) => void;
-}): IAgenticaController.IClass {
-  const validate: Validator = (input) => {
-    const result: IValidation<IAutoBeTestGenerationWriteApplication.IProps> =
-      typia.validate<IAutoBeTestGenerationWriteApplication.IProps>(input);
-    if (result.success === false) return result;
-
-    const errors: IValidation.IError[] = validateEmptyCode({
-      name: props.functionName,
-      draft: result.data.draft,
-      revise: result.data.revise,
-      path: "$input",
-      asynchronous: true,
-    });
-    return errors.length
-      ? {
-          success: false,
-          errors,
-          data: result.data,
-        }
-      : result;
-  };
-
-  const application: ILlmApplication =
-    typia.llm.application<IAutoBeTestGenerationWriteApplication>({
-      validate: {
-        generate: validate,
-      },
-    });
-
-  return {
-    protocol: "class",
-    name: "testGenerationWrite",
-    application,
-    execute: {
-      generate: (next) => {
-        props.build(next);
-      },
-    } satisfies IAutoBeTestGenerationWriteApplication,
-  };
-}
-
-type Validator = (
-  input: unknown,
-) => IValidation<IAutoBeTestGenerationWriteApplication.IProps>;
+import { IAgenticaController } from "@agentica/core";
+import {
+  AutoBeOpenApi,
+  AutoBeProgressEventBase,
+  AutoBeTestPrepareFunction,
+  AutoBeTestWriteEvent,
+} from "@autobe/interface";
+import { AutoBeOpenApiTypeChecker } from "@autobe/utils";
+import { IPointer } from "tstl";
+import typia, { ILlmApplication, IValidation } from "typia";
+import { v7 } from "uuid";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { executeCachedBatch } from "../../utils/executeCachedBatch";
+import { forceRetry } from "../../utils/forceRetry";
+import { validateEmptyCode } from "../../utils/validateEmptyCode";
+import { getTestArtifacts } from "./compile/getTestArtifacts";
+import { transformTestGenerateWriteHistory } from "./histories/transformTestGenerationWriteHistory";
+import { AutoBeTestGenerateProgrammer } from "./programmers/AutoBeTestGenerateProgrammer";
+import { IAutoBeTestArtifacts } from "./structures/IAutoBeTestArtifacts";
+import { IAutoBeTestGenerateProcedure } from "./structures/IAutoBeTestGenerateProcedure";
+import { IAutoBeTestGenerationWriteApplication } from "./structures/IAutoBeTestGenerationWriteApplication";
+
+export const orchestrateTestGenerateWrite = async (
+  ctx: AutoBeContext,
+  props: {
+    instruction: string;
+    document: AutoBeOpenApi.IDocument;
+    prepares: AutoBeTestPrepareFunction[];
+    progress: AutoBeProgressEventBase;
+  },
+): Promise<IAutoBeTestGenerateProcedure[]> => {
+  const result: Array<IAutoBeTestGenerateProcedure | null> =
+    await executeCachedBatch(
+      ctx,
+      props.document.operations.map((operation) => async (promptCacheKey) => {
+        if (operation.requestBody === null) return null;
+        else if (operation.requestBody.typeName.endsWith(".ICreate") === false)
+          return null;
+        else if (
+          props.document.components.schemas[operation.requestBody.typeName] ===
+          undefined
+        )
+          return null;
+        else if (
+          AutoBeOpenApiTypeChecker.isObject(
+            props.document.components.schemas[operation.requestBody.typeName],
+          ) === false
+        )
+          return null;
+
+        const prepareFunction: AutoBeTestPrepareFunction | undefined =
+          props.prepares.find(
+            (pf) => pf.typeName === operation.requestBody?.typeName,
+          );
+        if (prepareFunction === undefined) return null;
+
+        const artifacts: IAutoBeTestArtifacts = await getTestArtifacts(ctx, {
+          endpoint: {
+            path: operation.path,
+            method: operation.method,
+          },
+        });
+
+        try {
+          return await forceRetry(async () => {
+            const event: AutoBeTestWriteEvent = await process(ctx, {
+              prepare: prepareFunction,
+              artifacts,
+              operation,
+              progress: props.progress,
+              promptCacheKey,
+              instruction: props.instruction,
+            });
+            if (event.function.type !== "generate") return null;
+
+            ctx.dispatch(event);
+            return {
+              type: "generate",
+              prepare: prepareFunction,
+              artifacts,
+              function: event.function,
+              operation,
+            } satisfies IAutoBeTestGenerateProcedure;
+          });
+        } catch {
+          return null;
+        }
+      }),
+    );
+  return result.filter((r) => r !== null);
+};
+
+async function process(
+  ctx: AutoBeContext,
+  props: {
+    prepare: AutoBeTestPrepareFunction;
+    artifacts: IAutoBeTestArtifacts;
+    operation: AutoBeOpenApi.IOperation;
+    progress: AutoBeProgressEventBase;
+    promptCacheKey: string;
+    instruction: string;
+  },
+): Promise<AutoBeTestWriteEvent> {
+  const functionName: string = AutoBeTestGenerateProgrammer.getFunctionName(
+    props.operation,
+  );
+  const pointer: IPointer<IAutoBeTestGenerationWriteApplication.IProps | null> =
+    {
+      value: null,
+    };
+  const { metric, tokenUsage } = await ctx.conversate({
+    source: "testWrite",
+    controller: createController({
+      functionName,
+      build: (next) => {
+        pointer.value = next;
+      },
+    }),
+    enforceFunctionCall: true,
+    promptCacheKey: props.promptCacheKey,
+    ...(await transformTestGenerateWriteHistory(ctx, {
+      instruction: props.instruction,
+      prepare: props.prepare,
+      operation: props.operation,
+      artifacts: props.artifacts,
+    })),
+  });
+
+  if (pointer.value === null) {
+    ++props.progress.completed;
+    throw new Error("Failed to create generation function.");
+  }
+
+  const location: string = `test/generate/${functionName}.ts`;
+  return {
+    type: "testWrite",
+    id: v7(),
+    created_at: new Date().toISOString(),
+    function: {
+      type: "generate",
+      endpoint: {
+        method: props.operation.method,
+        path: props.operation.path,
+      },
+      actor: props.operation.authorizationActor,
+      location,
+      name: functionName,
+      content: await AutoBeTestGenerateProgrammer.replaceImportStatements({
+        compiler: await ctx.compiler(),
+        artifacts: props.artifacts,
+        prepare: props.prepare,
+        location,
+        content: pointer.value.revise.final ?? pointer.value.draft,
+      }),
+    },
+    metric,
+    tokenUsage,
+    completed: ++props.progress.completed,
+    total: props.progress.total,
+    step: ctx.state().test?.step ?? 0,
+  } satisfies AutoBeTestWriteEvent;
+}
+
+function createController(props: {
+  functionName: string;
+  build: (next: IAutoBeTestGenerationWriteApplication.IProps) => void;
+}): IAgenticaController.IClass {
+  const validate: Validator = (input) => {
+    const result: IValidation<IAutoBeTestGenerationWriteApplication.IProps> =
+      typia.validate<IAutoBeTestGenerationWriteApplication.IProps>(input);
+    if (result.success === false) return result;
+
+    const errors: IValidation.IError[] = validateEmptyCode({
+      name: props.functionName,
+      draft: result.data.draft,
+      revise: result.data.revise,
+      path: "$input",
+      asynchronous: true,
+    });
+    return errors.length
+      ? {
+          success: false,
+          errors,
+          data: result.data,
+        }
+      : result;
+  };
+
+  const application: ILlmApplication =
+    typia.llm.application<IAutoBeTestGenerationWriteApplication>({
+      validate: {
+        generate: validate,
+      },
+    });
+
+  return {
+    protocol: "class",
+    name: "testGenerationWrite",
+    application,
+    execute: {
+      generate: (next) => {
+        props.build(next);
+      },
+    } satisfies IAutoBeTestGenerationWriteApplication,
+  };
+}
+
+type Validator = (
+  input: unknown,
+) => IValidation<IAutoBeTestGenerationWriteApplication.IProps>;