@autobe/agent 0.5.2 → 0.7.0

package/src/orchestrate/test/orchestrateTestProgress.ts

@@ -0,0 +1,264 @@
+import { IAgenticaController, MicroAgentica } from "@agentica/core";
+import { AutoBeTest, AutoBeTestProgressEvent } from "@autobe/interface";
+import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
+import { IPointer } from "tstl";
+import typia from "typia";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { assertSchemaModel } from "../../context/assertSchemaModel";
+import { transformTestProgressHistories } from "./transformTestProgressHistories";
+
+export async function orchestrateTestProgress<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  scenarios: AutoBeTest.Scenario[],
+): Promise<AutoBeTestProgressEvent[]> {
+  const start: Date = new Date();
+  let complete: number = 0;
+
+  const events: AutoBeTestProgressEvent[] = await Promise.all(
+    /**
+     * Generate test code for each scenario. Maps through scenarios array to
+     * create individual test code implementations. Each scenario is processed
+     * to generate corresponding test code and progress events.
+     */
+    scenarios.map(async (scenario) => {
+      const code: ICreateTestCodeProps = await process(ctx, scenario);
+
+      const event: AutoBeTestProgressEvent = {
+        type: "testProgress",
+        created_at: start.toISOString(),
+        filename: `${code.domain}/${scenario.functionName}.ts`,
+        content: code.content,
+        completed: ++complete,
+        total: scenarios.length,
+        step: ctx.state().interface?.step ?? 0,
+      };
+      ctx.dispatch(event);
+      return event;
+    }),
+  );
+
+  return events;
+}
+
+/**
+ * Process function that generates test code for each individual scenario. Takes
+ * the AutoBeContext and scenario information as input and uses MicroAgentica to
+ * generate appropriate test code through LLM interaction.
+ *
+ * @param ctx - The AutoBeContext containing model, vendor and configuration
+ * @param scenario - The test scenario information to generate code for
+ * @returns Promise resolving to ICreateTestCodeProps containing the generated
+ *   test code
+ */
+async function process<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  scenario: AutoBeTest.Scenario,
+): Promise<ICreateTestCodeProps> {
+  const pointer: IPointer<ICreateTestCodeProps | null> = {
+    value: null,
+  };
+
+  const apiFiles = Object.entries(ctx.state().interface?.files ?? {})
+    .filter(([filename]) => {
+      return filename.startsWith("src/api/");
+    })
+    .reduce<Record<string, string>>((acc, [filename, content]) => {
+      return Object.assign(acc, { [filename]: content });
+    }, {});
+
+  const dtoFiles = Object.entries(ctx.state().interface?.files ?? {})
+    .filter(([filename]) => {
+      return filename.startsWith("src/api/structures/");
+    })
+    .reduce<Record<string, string>>((acc, [filename, content]) => {
+      return Object.assign(acc, { [filename]: content });
+    }, {});
+
+  const agentica = new MicroAgentica({
+    model: ctx.model,
+    vendor: ctx.vendor,
+    config: {
+      ...(ctx.config ?? {}),
+    },
+    histories: transformTestProgressHistories(apiFiles, dtoFiles),
+    controllers: [
+      createApplication({
+        model: ctx.model,
+        build: (next) => {
+          pointer.value = next;
+        },
+      }),
+    ],
+  });
+
+  agentica.on("request", async (event) => {
+    if (event.body.tools) event.body.tool_choice = "required";
+  });
+
+  await agentica.conversate(
+    [
+      "Create test code for below scenario:",
+      "",
+      "```json",
+      JSON.stringify(scenario, null, 2),
+      "```",
+    ].join("\n"),
+  );
+
+  if (pointer.value === null) throw new Error("Failed to create test code.");
+  return pointer.value;
+}
+
+function createApplication<Model extends ILlmSchema.Model>(props: {
+  model: Model;
+  build: (next: ICreateTestCodeProps) => void;
+}): IAgenticaController.IClass<Model> {
+  assertSchemaModel(props.model);
+
+  const application: ILlmApplication<Model> = collection[
+    props.model
+  ] as unknown as ILlmApplication<Model>;
+  return {
+    protocol: "class",
+    name: "Create Test Code",
+    application,
+    execute: {
+      createTestCode: (next) => {
+        props.build(next);
+      },
+    } satisfies IApplication,
+  };
+}
+
+const claude = typia.llm.application<
+  IApplication,
+  "claude",
+  {
+    reference: true;
+  }
+>();
+const collection = {
+  chatgpt: typia.llm.application<
+    IApplication,
+    "chatgpt",
+    { reference: true }
+  >(),
+  claude,
+  llama: claude,
+  deepseek: claude,
+  "3.1": claude,
+  "3.0": typia.llm.application<IApplication, "3.0">(),
+};
+
+interface IApplication {
+  createTestCode(props: ICreateTestCodeProps): void;
+}
+
+interface ICreateTestCodeProps {
+  /**
+   * Strategic approach for test implementation.
+   *
+   * Define the high-level strategy and logical flow for testing the given
+   * scenario. Focus on test methodology, data preparation, and assertion
+   * strategy.
+   *
+   * ### Critical Requirements
+   *
+   * - Must follow the Test Generation Guildelines.
+   * - Must Planning the test code Never occur the typescript compile error.
+   *
+   * ### Planning Elements:
+   *
+   * #### Test Methodology
+   *
+   * - Identify test scenario type (CRUD operation, authentication flow,
+   *   validation test)
+   * - Define test data requirements and preparation strategy
+   * - Plan positive/negative test cases and edge cases
+   * - Design assertion logic and validation points
+   *
+   * #### Execution Strategy
+   *
+   * - Outline step-by-step test execution flow
+   * - Plan error handling and exception scenarios
+   * - Define cleanup and teardown procedures
+   * - Identify dependencies and prerequisites
+   *
+   * ### Example Plan:
+   *
+   *     Test Strategy: Article Creation Validation
+   *     1. Prepare valid article data with required fields
+   *     2. Execute POST request to create article
+   *     3. Validate response structure and data integrity
+   *     4. Test error scenarios (missing fields, invalid data)
+   *     5. Verify database state changes
+   *     6. Reconsider the plan if it doesn't follow the Test Generation
+   *        Guildelines.
+   */
+  plan: string;
+
+  /**
+   * Functional domain classification for test organization.
+   *
+   * Determines file structure and test categorization based on API
+   * functionality. Used for organizing tests into logical groups and directory
+   * hierarchies.
+   *
+   * ### Naming Rules:
+   *
+   * - Lowercase English words only
+   * - Singular nouns (e.g., "article", "user", "comment")
+   * - Kebab-case for compound words (e.g., "user-profile", "payment-method")
+   * - Match primary API resource being tested
+   * - Domain Name must be named only one word.
+   *
+   * ### Domain Examples:
+   *
+   * - `article` → Article management operations
+   * - `comment` → Comment-related functionality
+   * - `auth` → Authentication and authorization
+   * - `user` → User management operations
+   * - `payment` → Payment processing
+   * - `notification` → Notification system
+   */
+  domain: string;
+
+  /**
+   * Complete TypeScript E2E test implementation.
+   *
+   * Generate fully functional, compilation-error-free test code following
+   *
+   * @nestia/e2e framework conventions and TypeScript best practices.
+   *
+   * ### Technical Implementation Requirements:
+   *
+   * #### Import Declarations
+   * ```typescript
+   * import api from "@ORGANIZATION/PROJECT-api";
+   * import { ITargetType } from "@ORGANIZATION/PROJECT-api/lib/structures/[path]";
+   * import { TestValidator } from "@nestia/e2e";
+   * import typia from "typia";
+   * ```
+   * - Must use exact `@ORGANIZATION/PROJECT-api` module path
+   * - Include `@ORGANIZATION` prefix in all API-related imports
+   * - Import specific DTO types from correct structure paths
+   *
+   * #### Code Quality Standards
+   * - Zero TypeScript compilation errors (mandatory)
+   * - Explicit type annotations for all variables
+   * - Proper async/await patterns throughout
+   * - Comprehensive error handling
+   * - Clean, readable code structure
+   * - Consistent formatting and naming conventions
+   *
+   * ### Critical Error Prevention
+   * - Verify all import paths are correct and accessible
+   * - Ensure type compatibility between variables and assignments
+   * - Include all required object properties and methods
+   * - Validate API function signatures and parameter types
+   * - Confirm proper generic type usage
+   * - Test async function declarations and Promise handling
+   */
+  content: string;
+}

package/src/orchestrate/test/orchestrateTestScenario.ts

@@ -0,0 +1,178 @@
+import { IAgenticaController, MicroAgentica } from "@agentica/core";
+import { AutoBeOpenApi, AutoBeTest } from "@autobe/interface";
+import { AutoBeTestScenarioEvent } from "@autobe/interface/src/events/AutoBeTestScenarioEvent";
+import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
+import { IPointer } from "tstl";
+import typia from "typia";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { assertSchemaModel } from "../../context/assertSchemaModel";
+import { transformTestScenarioHistories } from "./transformTestScenarioHistories";
+
+export async function orchestrateTestScenario<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+): Promise<AutoBeTestScenarioEvent> {
+  const files = Object.entries(ctx.state().interface?.files ?? {})
+    .filter(([filename]) => {
+      return filename.startsWith("test/features/api/");
+    })
+    .reduce<Record<string, string>>((acc, [filename, content]) => {
+      return Object.assign(acc, { [filename]: content });
+    }, {});
+
+  const operations = ctx.state().interface?.document.operations ?? [];
+  const endpoints: Omit<AutoBeOpenApi.IOperation, "specification">[] =
+    operations.map((it) => {
+      return {
+        method: it.method,
+        path: it.path,
+        summary: it.summary,
+        description: it.description,
+        parameters: it.parameters,
+        requestBody: it.requestBody,
+        responseBody: it.responseBody,
+      };
+    });
+
+  const start: Date = new Date();
+
+  let completed: number = 0;
+
+  const scenarios: AutoBeTest.IScenario[][] = await Promise.all(
+    endpoints.map(async (endpoint, i, arr) => {
+      const endponits = arr.filter((_el, j) => i !== j);
+      const rows: AutoBeTest.IScenario[] = await process(
+        ctx,
+        endpoint,
+        endponits,
+        files,
+      );
+      ctx.dispatch({
+        type: "testScenario",
+        scenarios: rows,
+        total: rows.flatMap((el) => el.scenarios).length,
+        step: ctx.state().test?.step ?? 0,
+        completed,
+        created_at: start.toISOString(),
+      });
+      return rows;
+    }),
+  );
+
+  return {
+    type: "testScenario",
+    scenarios: scenarios.flat(),
+    total: scenarios.flat().flatMap((el) => el.scenarios).length,
+    step: ctx.state().test?.step ?? 0,
+    completed,
+    created_at: start.toISOString(),
+  };
+}
+
+async function process<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  endpoint: AutoBeOpenApi.IEndpoint,
+  endpoints: AutoBeOpenApi.IEndpoint[],
+  files: Record<string, string>,
+): Promise<AutoBeTest.IScenario[]> {
+  const pointer: IPointer<AutoBeTest.IScenario[] | null> = {
+    value: null,
+  };
+
+  const agentica = new MicroAgentica({
+    model: ctx.model,
+    vendor: ctx.vendor,
+    config: {
+      ...(ctx.config ?? { locale: "en-US" }),
+      systemPrompt: {
+        describe: () => {
+          return "Answer only 'completion' or 'failure'.";
+        },
+      },
+    },
+    tokenUsage: ctx.usage(),
+    histories: [
+      ...transformTestScenarioHistories(ctx.state(), endpoints, files),
+    ],
+    controllers: [
+      createApplication({
+        model: ctx.model,
+        build: (next) => {
+          pointer.value = next.scenarios;
+        },
+      }),
+    ],
+  });
+
+  agentica.on("request", async (event) => {
+    if (event.body.tools) event.body.tool_choice = "required";
+  });
+
+  await agentica.conversate(
+    [
+      "Make User Scenarios for below endpoint:",
+      "",
+      "```json",
+      JSON.stringify(endpoint, null, 2),
+      "```",
+    ].join("\n"),
+  );
+
+  if (pointer.value === null) throw new Error("Failed to make scenarios.");
+  return pointer.value;
+}
+
+function createApplication<Model extends ILlmSchema.Model>(props: {
+  model: Model;
+  build: (next: IMakeScenarioProps) => void;
+}): IAgenticaController.IClass<Model> {
+  assertSchemaModel(props.model);
+
+  const application: ILlmApplication<Model> = collection[
+    props.model
+  ] as unknown as ILlmApplication<Model>;
+  return {
+    protocol: "class",
+    name: "Make User Scenarios",
+    application,
+    execute: {
+      makeScenario: (next) => {
+        props.build(next);
+      },
+    } satisfies IApplication,
+  };
+}
+
+const claude = typia.llm.application<
+  IApplication,
+  "claude",
+  {
+    reference: true;
+  }
+>();
+const collection = {
+  chatgpt: typia.llm.application<
+    IApplication,
+    "chatgpt",
+    { reference: true }
+  >(),
+  claude,
+  llama: claude,
+  deepseek: claude,
+  "3.1": claude,
+  "3.0": typia.llm.application<IApplication, "3.0">(),
+};
+
+interface IApplication {
+  /**
+   * Make user scenarios for the given endpoints.
+   *
+   * @param props Properties containing the endpoints and user scenarios.
+   */
+  makeScenario(props: IMakeScenarioProps): void;
+}
+
+interface IMakeScenarioProps {
+  /** Array of user scenarios. */
+  scenarios: AutoBeTest.IScenario[];
+}

package/src/orchestrate/test/transformTestCorrectHistories.ts

@@ -0,0 +1,51 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { v4 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
+
+export const transformTestCorrectHistories = (
+  apiFiles: Record<string, string>,
+  dtoFiles: Record<string, string>,
+): Array<
+  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+> => {
+  return [
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.TEST_CORRECT,
+    },
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "assistantMessage",
+      text: [
+        "You are the world's best TypeScript compiler error fixer.",
+        "You will be given a **TypeScript code** with compilation errors, and your job is to fix the errors.",
+        "",
+        "## Rules",
+        "- Follow the base E2E test style strictly. Never use other frameworks like Jest or Mocha.",
+        "- Use `TestValidator.equals(...)` and `typia.assert(...)` to verify results.",
+        "- Use `api.functional.XXX` for all API calls. These are defined in API Files.",
+        "- Use helper functions like `generate_random_xxx(...)` **only if** they already exist in the base test imports.",
+        "- Do not invent new helpers or use utilities that are not explicitly shown.",
+        "- Keep all tests deterministic and reliable.",
+        "",
+        "## File References",
+        "### API Files",
+        "```typescript",
+        JSON.stringify(apiFiles, null, 2),
+        "```",
+        "",
+        "### DTO Files",
+        "```typescript",
+        JSON.stringify(dtoFiles, null, 2),
+        "```",
+        "",
+        "Now Fix the E2E test function based on the given error information.",
+        "Only output a single `async function` named `test_api_{...}`. No explanation, no commentary.",
+      ].join("\n"),
+    },
+  ];
+};

package/src/orchestrate/test/transformTestHistories.ts

@@ -0,0 +1,77 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { v4 } from "uuid";
+
+import { AutoBeState } from "../../context/AutoBeState";
+
+export const transformTestHistories = (
+  state: AutoBeState,
+): Array<
+  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+> => {
+  if (state.analyze === null)
+    return [
+      {
+        id: v4(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: [
+          "Requirement analysis is not yet completed.",
+          "Don't call the any tool function,",
+          "but say to process the requirement analysis.",
+        ].join(" "),
+      },
+    ];
+  else if (state.prisma === null)
+    return [
+      {
+        id: v4(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: [
+          "Prisma DB schema generation is not yet completed.",
+          "Don't call the any tool function,",
+          "but say to process the Prisma DB schema generation.",
+        ].join(" "),
+      },
+    ];
+  else if (state.analyze.step !== state.prisma.step)
+    return [
+      {
+        id: v4(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: [
+          "Prisma DB schema generation has not been updated",
+          "for the latest requirement analysis.",
+          "Don't call the any tool function,",
+          "but say to re-process the Prisma DB schema generation.",
+        ].join(" "),
+      },
+    ];
+  else if (state.prisma.compiled.type !== "success")
+    return [
+      {
+        id: v4(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: [
+          "Prisma DB schema generation has not been updated",
+          "for the latest requirement analysis.",
+          "Don't call the any tool function,",
+          "but say to re-process the Prisma DB schema generation.",
+        ].join(" "),
+      },
+    ];
+  return [
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: [
+        "Interface generation is not yet completed.",
+        "Don't call the any tool function,",
+        "but say to process the interface generation.",
+      ].join(" "),
+    },
+  ];
+};

package/src/orchestrate/test/transformTestProgressHistories.ts

@@ -0,0 +1,51 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { v4 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
+
+export const transformTestProgressHistories = (
+  apiFiles: Record<string, string>,
+  dtoFiles: Record<string, string>,
+): Array<
+  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+> => {
+  return [
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.TEST_PROGRESS,
+    },
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "assistantMessage",
+      text: [
+        "You are the world's best E2E test code generator.",
+        "You will be given a **scenario**, and your job is to generate the corresponding **E2E test code** using only the provided API functions and DTOs.",
+        "",
+        "## Rules",
+        "- Follow the base E2E test style strictly. Never use other frameworks like Jest or Mocha.",
+        "- Use `TestValidator.equals(...)` and `typia.assert(...)` to verify results.",
+        "- Use `HubApi.functional.XXX` for all API calls. These are defined in API Files.",
+        "- Use helper functions like `generate_random_xxx(...)` **only if** they already exist in the base test imports.",
+        "- Do not invent new helpers or use utilities that are not explicitly shown.",
+        "- Keep all tests deterministic and reliable.",
+        "",
+        "## File References",
+        "### API Files",
+        "```typescript",
+        JSON.stringify(apiFiles, null, 2),
+        "```",
+        "",
+        "### DTO Files",
+        "```typescript",
+        JSON.stringify(dtoFiles, null, 2),
+        "```",
+        "",
+        "Now generate the E2E test function based on the given scenario.",
+        "Only output a single `async function` named `test_api_{...}`. No explanation, no commentary.",
+      ].join("\n"),
+    },
+  ];
+};