@autobe/agent 0.30.0-dev.20260315 → 0.30.1

package/src/orchestrate/test/orchestrateTest.ts

@@ -1,161 +1,161 @@
-import {
-  AutoBeAssistantMessageHistory,
-  AutoBeOpenApi,
-  AutoBeProgressEventBase,
-  AutoBeTestAuthorizeFunction,
-  AutoBeTestCompleteEvent,
-  AutoBeTestFunction,
-  AutoBeTestGenerateFunction,
-  AutoBeTestHistory,
-  AutoBeTestOperationFunction,
-  AutoBeTestPrepareFunction,
-  AutoBeTestScenario,
-  IAutoBeCompiler,
-} from "@autobe/interface";
-import { v7 } from "uuid";
-
-import { AutoBeContext } from "../../context/AutoBeContext";
-import { predicateStateMessage } from "../../utils/predicateStateMessage";
-import { IAutoBeFacadeApplicationProps } from "../facade/histories/IAutoBeFacadeApplicationProps";
-import { orchestrateTestAuthorize } from "./orchestrateTestAuthorize";
-import { orchestrateTestGenerate } from "./orchestrateTestGenerate";
-import { orchestrateTestOperation } from "./orchestrateTestOperation";
-import { orchestrateTestPrepare } from "./orchestrateTestPrepare";
-import { orchestrateTestScenario } from "./orchestrateTestScenario";
-import { AutoBeTestAuthorizeProgrammer } from "./programmers/AutoBeTestAuthorizeProgrammer";
-import { AutoBeTestGenerateProgrammer } from "./programmers/AutoBeTestGenerateProgrammer";
-import { AutoBeTestPrepareProgrammer } from "./programmers/AutoBeTestPrepareProgrammer";
-
-export const orchestrateTest =
-  (ctx: AutoBeContext) =>
-  async (
-    props: IAutoBeFacadeApplicationProps,
-  ): Promise<AutoBeAssistantMessageHistory | AutoBeTestHistory> => {
-    // PREDICATION
-    const start: Date = new Date();
-    const predicate: string | null = predicateStateMessage(ctx.state(), "test");
-    if (predicate !== null)
-      return ctx.assistantMessage({
-        type: "assistantMessage",
-        id: v7(),
-        created_at: start.toISOString(),
-        text: predicate,
-        completed_at: new Date().toISOString(),
-      });
-    ctx.dispatch({
-      type: "testStart",
-      id: v7(),
-      created_at: start.toISOString(),
-      reason: props.instruction,
-      step: ctx.state().analyze?.step ?? 0,
-    });
-    const document: AutoBeOpenApi.IDocument | undefined =
-      ctx.state().interface?.document;
-    if (document === undefined)
-      throw new Error("No document found. Please check the logs.");
-    else if (document.operations.length === 0)
-      return ctx.assistantMessage({
-        id: v7(),
-        type: "assistantMessage",
-        created_at: start.toISOString(),
-        completed_at: new Date().toISOString(),
-        text:
-          "Unable to write test code because there are no Operations, " +
-          "please check if the Interface agent is called.",
-      });
-
-    // SCENARIO PLANNING
-    const scenarios: AutoBeTestScenario[] = await orchestrateTestScenario(
-      ctx,
-      props.instruction,
-    );
-    if (scenarios.length === 0)
-      throw new Error("No scenarios generated. Please check the logs.");
-
-    const writeProgress: AutoBeProgressEventBase = {
-      completed: 0,
-      total:
-        AutoBeTestAuthorizeProgrammer.size(document) +
-        AutoBeTestPrepareProgrammer.size(document) +
-        AutoBeTestGenerateProgrammer.size(document) +
-        scenarios.length,
-    };
-    const correctProgress: AutoBeProgressEventBase = {
-      total: 0,
-      completed: 0,
-    };
-
-    // AUTHORIZE
-    const authorizes: AutoBeTestAuthorizeFunction[] =
-      await orchestrateTestAuthorize(ctx, {
-        instruction: props.instruction,
-        document,
-        writeProgress,
-        validateProgress: correctProgress,
-      });
-
-    // DATA COMPOSER
-    const prepares: AutoBeTestPrepareFunction[] = await orchestrateTestPrepare(
-      ctx,
-      {
-        instruction: props.instruction,
-        document,
-        writeProgress,
-        validateProgress: correctProgress,
-      },
-    );
-
-    // GENERATOR FUNCTIONS (C of CRUD)
-    const generates: AutoBeTestGenerateFunction[] =
-      await orchestrateTestGenerate(ctx, {
-        instruction: props.instruction,
-        document,
-        prepares,
-        writeProgress,
-        validateProgress: correctProgress,
-      });
-
-    // ACTUAL TEST FUNCTION
-    const operations: AutoBeTestOperationFunction[] =
-      await orchestrateTestOperation(ctx, {
-        instruction: props.instruction,
-        document,
-        scenarios,
-        authorizes,
-        prepares,
-        generates,
-        writeProgress,
-        validateProgress: correctProgress,
-      });
-
-    // FINALIZE WITH COMPILATION
-    const compiler: IAutoBeCompiler = await ctx.compiler();
-    const functions: AutoBeTestFunction[] = [
-      ...authorizes,
-      ...prepares,
-      ...generates,
-      ...operations,
-    ];
-    return ctx.dispatch({
-      type: "testComplete",
-      id: v7(),
-      functions,
-      compiled: await compiler.typescript.compile({
-        files: Object.fromEntries([
-          ...Object.entries(
-            await ctx.files({
-              dbms: "sqlite",
-            }),
-          ).filter(
-            ([key]) =>
-              key.endsWith(".ts") && key.startsWith("test/features") === false,
-          ),
-          ...functions.map((f) => [f.location, f.content]),
-        ]),
-      }),
-      aggregates: ctx.getCurrentAggregates("test"),
-      step: ctx.state().analyze?.step ?? 0,
-      elapsed: new Date().getTime() - start.getTime(),
-      created_at: new Date().toISOString(),
-    } satisfies AutoBeTestCompleteEvent);
-  };
+import {
+  AutoBeAssistantMessageHistory,
+  AutoBeOpenApi,
+  AutoBeProgressEventBase,
+  AutoBeTestAuthorizeFunction,
+  AutoBeTestCompleteEvent,
+  AutoBeTestFunction,
+  AutoBeTestGenerateFunction,
+  AutoBeTestHistory,
+  AutoBeTestOperationFunction,
+  AutoBeTestPrepareFunction,
+  AutoBeTestScenario,
+  IAutoBeCompiler,
+} from "@autobe/interface";
+import { v7 } from "uuid";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { predicateStateMessage } from "../../utils/predicateStateMessage";
+import { IAutoBeFacadeApplicationProps } from "../facade/histories/IAutoBeFacadeApplicationProps";
+import { orchestrateTestAuthorize } from "./orchestrateTestAuthorize";
+import { orchestrateTestGenerate } from "./orchestrateTestGenerate";
+import { orchestrateTestOperation } from "./orchestrateTestOperation";
+import { orchestrateTestPrepare } from "./orchestrateTestPrepare";
+import { orchestrateTestScenario } from "./orchestrateTestScenario";
+import { AutoBeTestAuthorizeProgrammer } from "./programmers/AutoBeTestAuthorizeProgrammer";
+import { AutoBeTestGenerateProgrammer } from "./programmers/AutoBeTestGenerateProgrammer";
+import { AutoBeTestPrepareProgrammer } from "./programmers/AutoBeTestPrepareProgrammer";
+
+export const orchestrateTest =
+  (ctx: AutoBeContext) =>
+  async (
+    props: IAutoBeFacadeApplicationProps,
+  ): Promise<AutoBeAssistantMessageHistory | AutoBeTestHistory> => {
+    // PREDICATION
+    const start: Date = new Date();
+    const predicate: string | null = predicateStateMessage(ctx.state(), "test");
+    if (predicate !== null)
+      return ctx.assistantMessage({
+        type: "assistantMessage",
+        id: v7(),
+        created_at: start.toISOString(),
+        text: predicate,
+        completed_at: new Date().toISOString(),
+      });
+    ctx.dispatch({
+      type: "testStart",
+      id: v7(),
+      created_at: start.toISOString(),
+      reason: props.instruction,
+      step: ctx.state().analyze?.step ?? 0,
+    });
+    const document: AutoBeOpenApi.IDocument | undefined =
+      ctx.state().interface?.document;
+    if (document === undefined)
+      throw new Error("No document found. Please check the logs.");
+    else if (document.operations.length === 0)
+      return ctx.assistantMessage({
+        id: v7(),
+        type: "assistantMessage",
+        created_at: start.toISOString(),
+        completed_at: new Date().toISOString(),
+        text:
+          "Unable to write test code because there are no Operations, " +
+          "please check if the Interface agent is called.",
+      });
+
+    // SCENARIO PLANNING
+    const scenarios: AutoBeTestScenario[] = await orchestrateTestScenario(
+      ctx,
+      props.instruction,
+    );
+    if (scenarios.length === 0)
+      throw new Error("No scenarios generated. Please check the logs.");
+
+    const writeProgress: AutoBeProgressEventBase = {
+      completed: 0,
+      total:
+        AutoBeTestAuthorizeProgrammer.size(document) +
+        AutoBeTestPrepareProgrammer.size(document) +
+        AutoBeTestGenerateProgrammer.size(document) +
+        scenarios.length,
+    };
+    const correctProgress: AutoBeProgressEventBase = {
+      total: 0,
+      completed: 0,
+    };
+
+    // AUTHORIZE
+    const authorizes: AutoBeTestAuthorizeFunction[] =
+      await orchestrateTestAuthorize(ctx, {
+        instruction: props.instruction,
+        document,
+        writeProgress,
+        validateProgress: correctProgress,
+      });
+
+    // DATA COMPOSER
+    const prepares: AutoBeTestPrepareFunction[] = await orchestrateTestPrepare(
+      ctx,
+      {
+        instruction: props.instruction,
+        document,
+        writeProgress,
+        validateProgress: correctProgress,
+      },
+    );
+
+    // GENERATOR FUNCTIONS (C of CRUD)
+    const generates: AutoBeTestGenerateFunction[] =
+      await orchestrateTestGenerate(ctx, {
+        instruction: props.instruction,
+        document,
+        prepares,
+        writeProgress,
+        validateProgress: correctProgress,
+      });
+
+    // ACTUAL TEST FUNCTION
+    const operations: AutoBeTestOperationFunction[] =
+      await orchestrateTestOperation(ctx, {
+        instruction: props.instruction,
+        document,
+        scenarios,
+        authorizes,
+        prepares,
+        generates,
+        writeProgress,
+        validateProgress: correctProgress,
+      });
+
+    // FINALIZE WITH COMPILATION
+    const compiler: IAutoBeCompiler = await ctx.compiler();
+    const functions: AutoBeTestFunction[] = [
+      ...authorizes,
+      ...prepares,
+      ...generates,
+      ...operations,
+    ];
+    return ctx.dispatch({
+      type: "testComplete",
+      id: v7(),
+      functions,
+      compiled: await compiler.typescript.compile({
+        files: Object.fromEntries([
+          ...Object.entries(
+            await ctx.files({
+              dbms: "sqlite",
+            }),
+          ).filter(
+            ([key]) =>
+              key.endsWith(".ts") && key.startsWith("test/features") === false,
+          ),
+          ...functions.map((f) => [f.location, f.content]),
+        ]),
+      }),
+      aggregates: ctx.getCurrentAggregates("test"),
+      step: ctx.state().analyze?.step ?? 0,
+      elapsed: new Date().getTime() - start.getTime(),
+      created_at: new Date().toISOString(),
+    } satisfies AutoBeTestCompleteEvent);
+  };

package/src/orchestrate/test/orchestrateTestAuthorize.ts

@@ -1,125 +1,125 @@
-import {
-  AutoBeEventSource,
-  AutoBeOpenApi,
-  AutoBeProgressEventBase,
-  AutoBeTestAuthorizeFunction,
-} 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 { orchestrateTestAuthorizeWrite } from "./orchestrateTestAuthorizeWrite";
-import { AutoBeTestAuthorizeProgrammer } from "./programmers/AutoBeTestAuthorizeProgrammer";
-import { IAutoBeTestAuthorizeProcedure } from "./structures/IAutoBeTestAuthorizeWriteResult";
-import { IAutoBeTestCorrectOverallApplication } from "./structures/IAutoBeTestCorrectOverallApplication";
-
-export async function orchestrateTestAuthorize(
-  ctx: AutoBeContext,
-  props: {
-    instruction: string;
-    document: AutoBeOpenApi.IDocument;
-    writeProgress: AutoBeProgressEventBase;
-    validateProgress: AutoBeProgressEventBase;
-  },
-): Promise<AutoBeTestAuthorizeFunction[]> {
-  const compile = async (procedure: IAutoBeTestAuthorizeProcedure) =>
-    AutoBeTestAuthorizeProgrammer.compile({
-      compiler: await ctx.compiler(),
-      procedure,
-      progress: props.validateProgress,
-      step: ctx.state().analyze?.step ?? 0,
-    });
-  const replaceImportStatements = async (
-    procedure: IAutoBeTestAuthorizeProcedure,
-  ) =>
-    AutoBeTestAuthorizeProgrammer.replaceImportStatements({
-      compiler: await ctx.compiler(),
-      artifacts: procedure.artifacts,
-      content: procedure.function.content,
-    });
-
-  let procedures: IAutoBeTestAuthorizeProcedure[] =
-    await orchestrateTestAuthorizeWrite(ctx, {
-      instruction: props.instruction,
-      document: props.document,
-      progress: props.writeProgress,
-    });
-  procedures = await orchestrateTestCorrectCasting(ctx, {
-    programmer: {
-      compile,
-      replaceImportStatements,
-      asynchronous: true,
-    },
-    procedures,
-    progress: props.validateProgress,
-  });
-  // procedures = await orchestrateTestCorrectRequest(ctx, {
-  //   programmer: {
-  //     compile,
-  //     replaceImportStatements,
-  //   },
-  //   instruction: props.instruction,
-  //   procedures,
-  //   progress: props.correctProgress,
-  // });
-  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: IAutoBeTestAuthorizeProcedure;
-  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[] = AutoBeTestAuthorizeProgrammer.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,
+  AutoBeTestAuthorizeFunction,
+} 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 { orchestrateTestAuthorizeWrite } from "./orchestrateTestAuthorizeWrite";
+import { AutoBeTestAuthorizeProgrammer } from "./programmers/AutoBeTestAuthorizeProgrammer";
+import { IAutoBeTestAuthorizeProcedure } from "./structures/IAutoBeTestAuthorizeWriteResult";
+import { IAutoBeTestCorrectOverallApplication } from "./structures/IAutoBeTestCorrectOverallApplication";
+
+export async function orchestrateTestAuthorize(
+  ctx: AutoBeContext,
+  props: {
+    instruction: string;
+    document: AutoBeOpenApi.IDocument;
+    writeProgress: AutoBeProgressEventBase;
+    validateProgress: AutoBeProgressEventBase;
+  },
+): Promise<AutoBeTestAuthorizeFunction[]> {
+  const compile = async (procedure: IAutoBeTestAuthorizeProcedure) =>
+    AutoBeTestAuthorizeProgrammer.compile({
+      compiler: await ctx.compiler(),
+      procedure,
+      progress: props.validateProgress,
+      step: ctx.state().analyze?.step ?? 0,
+    });
+  const replaceImportStatements = async (
+    procedure: IAutoBeTestAuthorizeProcedure,
+  ) =>
+    AutoBeTestAuthorizeProgrammer.replaceImportStatements({
+      compiler: await ctx.compiler(),
+      artifacts: procedure.artifacts,
+      content: procedure.function.content,
+    });
+
+  let procedures: IAutoBeTestAuthorizeProcedure[] =
+    await orchestrateTestAuthorizeWrite(ctx, {
+      instruction: props.instruction,
+      document: props.document,
+      progress: props.writeProgress,
+    });
+  procedures = await orchestrateTestCorrectCasting(ctx, {
+    programmer: {
+      compile,
+      replaceImportStatements,
+      asynchronous: true,
+    },
+    procedures,
+    progress: props.validateProgress,
+  });
+  // procedures = await orchestrateTestCorrectRequest(ctx, {
+  //   programmer: {
+  //     compile,
+  //     replaceImportStatements,
+  //   },
+  //   instruction: props.instruction,
+  //   procedures,
+  //   progress: props.correctProgress,
+  // });
+  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: IAutoBeTestAuthorizeProcedure;
+  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[] = AutoBeTestAuthorizeProgrammer.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>;