@autobe/agent 0.9.0 → 0.9.2

package/src/orchestrate/interface/orchestrateInterface.ts

@@ -22,6 +22,13 @@ export const orchestrateInterface =
   ): Promise<AutoBeAssistantMessageHistory | AutoBeInterfaceHistory> => {
     // ENDPOINTS
     const start: Date = new Date();
+    ctx.dispatch({
+      type: "interfaceStart",
+      created_at: start.toISOString(),
+      reason: props.reason,
+      step: ctx.state().analyze?.step ?? 0,
+    });
+
     const init: AutoBeAssistantMessageHistory | AutoBeInterfaceEndpointsEvent =
       await orchestrateInterfaceEndpoints(ctx);
     if (init.type === "assistantMessage") {

package/src/orchestrate/test/compileTestScenario.ts

@@ -0,0 +1,64 @@
+import { AutoBeOpenApi, AutoBeTestScenario } from "@autobe/interface";
+import { ILlmSchema, OpenApiTypeChecker } from "@samchon/openapi";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { IAutoBeTestScenarioArtifacts } from "./structures/IAutoBeTestScenarioArtifacts";
+
+export async function compileTestScenario<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  scenario: AutoBeTestScenario,
+): Promise<IAutoBeTestScenarioArtifacts> {
+  const document: AutoBeOpenApi.IDocument = filterDocument(
+    scenario,
+    ctx.state().interface!.document,
+  );
+  const entries: [string, string][] = Object.entries(
+    await ctx.compiler.interface.compile(document),
+  );
+  const filter = (prefix: string) =>
+    Object.fromEntries(entries.filter(([key]) => key.startsWith(prefix)));
+  return {
+    document,
+    sdk: filter("src/api/functional"),
+    dto: filter("src/api/structures"),
+    e2e: filter("test/features"),
+  };
+}
+
+function filterDocument(
+  scenario: AutoBeTestScenario,
+  document: AutoBeOpenApi.IDocument,
+): AutoBeOpenApi.IDocument {
+  const operations: AutoBeOpenApi.IOperation[] = document.operations.filter(
+    (op) =>
+      (scenario.endpoint.method === op.method &&
+        scenario.endpoint.path === op.path) ||
+      scenario.dependencies.some(
+        (dp) =>
+          dp.endpoint.method === op.method && dp.endpoint.path === op.path,
+      ),
+  );
+  const components: AutoBeOpenApi.IComponents = {
+    schemas: {},
+  };
+  const visit = (typeName: string) => {
+    OpenApiTypeChecker.visit({
+      components: document.components,
+      schema: { $ref: `#/components/schemas/${typeName}` },
+      closure: (s) => {
+        if (OpenApiTypeChecker.isReference(s)) {
+          const key: string = s.$ref.split("/").pop()!;
+          components.schemas[key] = document.components.schemas[key];
+        }
+      },
+    });
+  };
+  for (const op of operations) {
+    if (op.requestBody) visit(op.requestBody.typeName);
+    if (op.responseBody) visit(op.responseBody.typeName);
+  }
+  return {
+    operations,
+    components,
+  };
+}

package/src/orchestrate/test/filterTestFileName.ts

@@ -0,0 +1,9 @@
+export function filterTestFileName(key: string): boolean {
+  if (key.endsWith(".ts") === false) return false;
+  else if (key.startsWith("src/") === true) return true;
+  return (
+    key.startsWith("test/") === true &&
+    key.startsWith("test/features/") === false &&
+    key.startsWith("test/benchmark/") === false
+  );
+}

package/src/orchestrate/test/orchestrateTest.ts

@@ -1,6 +1,8 @@
 import {
   AutoBeAssistantMessageHistory,
+  AutoBeOpenApi,
   AutoBeTestHistory,
+  AutoBeTestValidateEvent,
   AutoBeTestWriteEvent,
 } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
@@ -9,8 +11,8 @@ import { v4 } from "uuid";
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
 import { orchestrateTestCorrect } from "./orchestrateTestCorrect";
-import { orchestrateTestProgress } from "./orchestrateTestProgress";
 import { orchestrateTestScenario } from "./orchestrateTestScenario";
+import { orchestrateTestWrite } from "./orchestrateTestWrite";
 
 export const orchestrateTest =
   <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) =>
@@ -25,7 +27,8 @@ export const orchestrateTest =
       step: ctx.state().analyze?.step ?? 0,
     });
 
-    const operations = ctx.state().interface?.document.operations ?? [];
+    const operations: AutoBeOpenApi.IOperation[] =
+      ctx.state().interface?.document.operations ?? [];
     if (operations.length === 0) {
       const history: AutoBeAssistantMessageHistory = {
         id: v4(),
@@ -36,10 +39,8 @@ export const orchestrateTest =
           "Unable to write test code because there are no Operations, " +
           "please check if the Interface agent is called.",
       };
-
       ctx.histories().push(history);
       ctx.dispatch(history);
-
       return history;
     }
 
@@ -47,13 +48,16 @@ export const orchestrateTest =
     const { scenarios } = await orchestrateTestScenario(ctx);
 
     // TEST CODE
-    const codes: AutoBeTestWriteEvent[] = await orchestrateTestProgress(
+    const codes: AutoBeTestWriteEvent[] = await orchestrateTestWrite(
       ctx,
       scenarios,
     );
 
-    const correct = await orchestrateTestCorrect(ctx, codes, scenarios);
-
+    const correct: AutoBeTestValidateEvent = await orchestrateTestCorrect(
+      ctx,
+      codes,
+      scenarios,
+    );
     const history: AutoBeTestHistory = {
       type: "test",
       id: v4(),
@@ -64,11 +68,13 @@ export const orchestrateTest =
       reason: "Step to the test generation referencing the interface",
       step: ctx.state().interface?.step ?? 0,
     };
-
     ctx.dispatch({
       type: "testComplete",
       created_at: start.toISOString(),
-      files: correct.files,
+      files: correct.files
+        .map((f) => ({ [f.location]: f.content }))
+        .reduce((acc, cur) => Object.assign(acc, cur), {}),
+      compiled: correct.result,
       step: ctx.state().interface?.step ?? 0,
     });