@autobe/agent 0.9.2 → 0.10.0

package/src/orchestrate/realize/transformRealizeCoderHistories.ts

@@ -0,0 +1,136 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { v4 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
+import { AutoBeState } from "../../context/AutoBeState";
+import { IAutoBeTestScenarioArtifacts } from "../test/structures/IAutoBeTestScenarioArtifacts";
+import { RealizePlannerOutput } from "./orchestrateRealizePlanner";
+
+export const transformRealizeCoderHistories = (
+  state: AutoBeState,
+  props: RealizePlannerOutput,
+  artifacts: IAutoBeTestScenarioArtifacts,
+): 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(" "),
+      },
+    ];
+  else if (state.interface === null)
+    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(" "),
+      },
+    ];
+
+  return [
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: [
+        AutoBeSystemPromptConstant.REALIZE_CODER,
+        "",
+        "# Prisma Schemas",
+        "```json",
+        JSON.stringify(state.prisma.schemas),
+        "```",
+        "",
+        // "# Prisma Types",
+        // "```json",
+        // JSON.stringify(state.prisma.compiled.nodeModules),
+        // "```",
+        "# SDK",
+        "",
+        "The following is the SDK for the API. Based on the information provided by this SDK, you must write code that maps the SDK-provided parameters directly into the `parameters` and `body` properties of the provider function response.",
+        "If there are no parameters, define `parameters` as `Record<string, never>`. Similarly, if there is no body, define `body` as `Record<string, never>`.",
+        "**Every function must be implemented to accept both `parameters` and `body`, without exception.**",
+        "If any required type information is referenced in the SDK, refer to the definitions in the DTO section.",
+        "",
+        "```json",
+        JSON.stringify(artifacts.sdk),
+        "```",
+        "",
+        "# DTO",
+        "if you want to import this files, write this: 'import { something } from '../api/structures/something';'",
+        "",
+        "```json",
+        JSON.stringify(artifacts.dto),
+        "```",
+        "# Document",
+        "```json",
+        JSON.stringify(artifacts.document),
+        "```",
+      ].join("\n"),
+    },
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: [
+        "write code by following information of operation.",
+        "```json",
+        JSON.stringify(props),
+        "```",
+      ].join("\n"),
+    },
+  ];
+};

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

@@ -0,0 +1,35 @@
+import { IAutoBeTestScenarioArtifacts } from "../structures/IAutoBeTestScenarioArtifacts";
+
+export function completeTestCode(
+  artifacts: IAutoBeTestScenarioArtifacts,
+  code: string,
+): string {
+  const typeReferences: string[] = Array.from(
+    new Set(
+      Object.keys(artifacts.document.components.schemas).map(
+        (key) => key.split(".")[0]!,
+      ),
+    ),
+  );
+
+  code = code.replace(/^[ \t]*import\b[\s\S]*?;[ \t]*$/gm, "").trim();
+  code = code.replace(/^[ \t]*import\b[\s\S]*?;[ \t]*$/gm, "").trim();
+  code = code.replaceAll(
+    'string & Format<"uuid">',
+    'string & tags.Format<"uuid">',
+  );
+  code = [
+    `import { ArrayUtil, RandomGenerator, TestValidator } from "@nestia/e2e";`,
+    `import { IConnection } from "@nestia/fetcher";`,
+    `import typia, { tags } from "typia";`,
+    "",
+    `import api from "@ORGANIZATION/PROJECT-api";`,
+    ...typeReferences.map(
+      (ref) =>
+        `import type { ${ref} } from "@ORGANIZATION/PROJECT-api/lib/structures/${ref}";`,
+    ),
+    "",
+    code,
+  ].join("\n");
+  return code;
+}

package/src/orchestrate/test/{filterTestFileName.ts → compile/filterTestFileName.ts}

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

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

@@ -0,0 +1,24 @@
+import { IAutoBeTestCompiler } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { Singleton } from "tstl";
+
+import { AutoBeContext } from "../../../context/AutoBeContext";
+
+export function getTestExternalDeclarations<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+): Promise<Record<string, string>> {
+  return singleton.get(ctx.compiler.test);
+}
+
+const singleton = new Singleton(async (compiler: IAutoBeTestCompiler) => {
+  const records: Record<string, string> = await compiler.getExternal();
+  const external = (location: string): Record<string, string> => {
+    const content: string | undefined = records[location];
+    if (content === undefined) throw new Error(`File not found: ${location}`);
+    return { [location]: content };
+  };
+  return {
+    ...external("node_modules/@nestia/e2e/lib/TestValidator.d.ts"),
+    ...external("node_modules/@nestia/fetcher/lib/IConnection.d.ts"),
+  } satisfies Record<string, string>;
+});

package/src/orchestrate/test/{compileTestScenario.ts → compile/getTestScenarioArtifacts.ts}

@@ -1,12 +1,12 @@
 import { AutoBeOpenApi, AutoBeTestScenario } from "@autobe/interface";
 import { ILlmSchema, OpenApiTypeChecker } from "@samchon/openapi";
 
-import { AutoBeContext } from "../../context/AutoBeContext";
-import { IAutoBeTestScenarioArtifacts } from "./structures/IAutoBeTestScenarioArtifacts";
+import { AutoBeContext } from "../../../context/AutoBeContext";
+import { IAutoBeTestScenarioArtifacts } from "../structures/IAutoBeTestScenarioArtifacts";
 
-export async function compileTestScenario<Model extends ILlmSchema.Model>(
+export async function getTestScenarioArtifacts<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  scenario: AutoBeTestScenario,
+  scenario: Pick<AutoBeTestScenario, "endpoint" | "dependencies">,
 ): Promise<IAutoBeTestScenarioArtifacts> {
   const document: AutoBeOpenApi.IDocument = filterDocument(
     scenario,
@@ -15,18 +15,26 @@ export async function compileTestScenario<Model extends ILlmSchema.Model>(
   const entries: [string, string][] = Object.entries(
     await ctx.compiler.interface.compile(document),
   );
-  const filter = (prefix: string) =>
-    Object.fromEntries(entries.filter(([key]) => key.startsWith(prefix)));
+  const filter = (prefix: string, exclude?: string) => {
+    const result: [string, string][] = entries.filter(
+      ([key]) => key.startsWith(prefix) === true,
+    );
+    return Object.fromEntries(
+      exclude
+        ? result.filter(([key]) => key.startsWith(exclude) === false)
+        : result,
+    );
+  };
   return {
     document,
-    sdk: filter("src/api/functional"),
+    sdk: filter("src/api", "src/api/structures"),
     dto: filter("src/api/structures"),
     e2e: filter("test/features"),
   };
 }
 
 function filterDocument(
-  scenario: AutoBeTestScenario,
+  scenario: Pick<AutoBeTestScenario, "endpoint" | "dependencies">,
   document: AutoBeOpenApi.IDocument,
 ): AutoBeOpenApi.IDocument {
   const operations: AutoBeOpenApi.IOperation[] = document.operations.filter(

package/src/orchestrate/test/experimental/orchestrateTestCorrect.ast

@@ -0,0 +1,240 @@
+import {
+  AgenticaSystemPrompt,
+  IAgenticaController,
+  MicroAgentica,
+} from "@agentica/core";
+import {
+  AutoBeTest,
+  AutoBeTestValidateEvent,
+  IAutoBeTypeScriptCompileResult,
+} from "@autobe/interface";
+import {
+  ILlmApplication,
+  ILlmSchema,
+  OpenApi,
+  OpenApiTypeChecker,
+} from "@samchon/openapi";
+import { IPointer } from "tstl";
+import typia, { IJsonSchemaUnit } from "typia";
+
+import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { assertSchemaModel } from "../../context/assertSchemaModel";
+import { enforceToolCall } from "../../utils/enforceToolCall";
+import { IAutoBeTestWriteResult } from "./structures/IAutoBeTestWriteResult";
+import { transformTestCorrectHistories } from "./transformTestCorrectHistories";
+
+export function orchestrateTestCorrect<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  results: IAutoBeTestWriteResult[],
+  life: number = 4,
+): Promise<AutoBeTestValidateEvent[]> {
+  return Promise.all(
+    results.map(async (written) => {
+      const event: AutoBeTestValidateEvent = await compile(ctx, written);
+      return predicate(ctx, written, event, life);
+    }),
+  );
+}
+
+async function predicate<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  written: IAutoBeTestWriteResult,
+  event: AutoBeTestValidateEvent,
+  life: number,
+): Promise<AutoBeTestValidateEvent> {
+  ctx.dispatch(event);
+  return event.result.type === "failure"
+    ? correct(ctx, written, event, life - 1)
+    : event;
+}
+
+async function correct<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  written: IAutoBeTestWriteResult,
+  event: AutoBeTestValidateEvent,
+  life: number,
+): Promise<AutoBeTestValidateEvent> {
+  if (event.result.type !== "failure") return event;
+  else if (--life <= 0) return event;
+
+  const pointer: IPointer<ICorrectTestFunctionProps | null> = {
+    value: null,
+  };
+  const agentica = new MicroAgentica({
+    model: ctx.model,
+    vendor: { ...ctx.vendor },
+    config: {
+      ...(ctx.config ?? {}),
+      executor: {
+        describe: null,
+      },
+      systemPrompt: {
+        validate: (events) =>
+          [
+            AgenticaSystemPrompt.VALIDATE_REPEATED.replace(
+              "${{HISTORICAL_ERRORS}}",
+              JSON.stringify(events.map((e) => e.result.errors)),
+            ),
+            AutoBeSystemPromptConstant.TEST_VALIDATE.replace(
+              "${{AutoBeTest.IStatement}}",
+              getUnionTypeName(typia.json.schema<AutoBeTest.IStatement>()),
+            ).replace(
+              "${{AutoBeTest.IExpression}}",
+              getUnionTypeName(typia.json.schema<AutoBeTest.IExpression>()),
+            ),
+          ].join("\n\n"),
+      },
+      retry: 4,
+    },
+    histories: transformTestCorrectHistories(written, event.result),
+    controllers: [
+      createApplication({
+        model: ctx.model,
+        build: (next) => {
+          pointer.value = next;
+        },
+      }),
+    ],
+  });
+  enforceToolCall(agentica);
+
+  await agentica
+    .conversate(
+      "Fix the `AutoBeTest.IFunction` data to resolve the compilation error.",
+    )
+    .finally(() => {
+      const tokenUsage = agentica.getTokenUsage();
+      ctx.usage().record(tokenUsage, ["test"]);
+    });
+  if (pointer.value === null) throw new Error("Failed to modify test code.");
+  event = await compile(ctx, {
+    ...written,
+    file: {
+      ...written.file,
+      function: pointer.value.function,
+    },
+  });
+  return predicate(ctx, written, event, life);
+}
+
+async function compile<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  written: IAutoBeTestWriteResult,
+): Promise<AutoBeTestValidateEvent> {
+  const compiled: IAutoBeTypeScriptCompileResult =
+    await ctx.compiler.test.compile({
+      files: {
+        ...written.artifacts.dto,
+        ...written.artifacts.sdk,
+        [written.file.location]: written.file.content,
+      },
+    });
+  return {
+    type: "testValidate",
+    file: written.file,
+    result: compiled,
+    created_at: new Date().toISOString(),
+    step: ctx.state().analyze?.step ?? 0,
+  };
+}
+
+function getUnionTypeName(unit: IJsonSchemaUnit): string {
+  if (OpenApiTypeChecker.isReference(unit.schema) === false) return "unknown";
+
+  const typeName: string = unit.schema.$ref.split("/").pop() ?? "";
+  const schema: OpenApi.IJsonSchema | undefined =
+    unit.components.schemas?.[typeName];
+  if (schema === undefined || OpenApiTypeChecker.isOneOf(schema) === false)
+    return "unknown";
+  return schema.oneOf
+    .filter(OpenApiTypeChecker.isReference)
+    .map((r) => r.$ref.split("/").pop() ?? "")
+    .join(" | ");
+}
+
+function createApplication<Model extends ILlmSchema.Model>(props: {
+  model: Model;
+  build: (next: ICorrectTestFunctionProps) => void;
+}): IAgenticaController.IClass<Model> {
+  assertSchemaModel(props.model);
+
+  const application: ILlmApplication<Model> = collection[
+    props.model
+  ] as unknown as ILlmApplication<Model>;
+  return {
+    protocol: "class",
+    name: "Modify Test Code",
+    application,
+    execute: {
+      correctTestCode: (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,
+};
+
+interface IApplication {
+  correctTestCode(props: ICorrectTestFunctionProps): void;
+}
+
+interface ICorrectTestFunctionProps {
+  /**
+   * Step 1: Initial self-reflection on the source code without compiler error
+   * context.
+   *
+   * The AI agent analyzes the previously generated test code to identify
+   * potential issues, relying solely on its understanding of TypeScript syntax,
+   * testing patterns, and best practices.
+   *
+   * This encourages the agent to develop independent debugging skills before
+   * being influenced by external error messages.
+   */
+  think_without_compile_error: string;
+
+  /**
+   * Step 2: Re-evaluation of the code with compiler error messages as
+   * additional context.
+   *
+   * After the initial analysis, the AI agent reviews the same code again, this
+   * time incorporating the specific TypeScript compiler error messages.
+   *
+   * This allows the agent to correlate its initial observations with concrete
+   * compilation failures and refine its understanding of what went wrong.
+   */
+  think_again_with_compile_error: string;
+
+  /**
+   * Step 3: Concrete action plan for fixing the identified issues.
+   *
+   * Based on the analysis from steps 1 and 2, the AI agent formulates a
+   * specific, step-by-step solution strategy.
+   *
+   * This should include what changes need to be made, why those changes are
+   * necessary, and how they will resolve the compilation errors while
+   * maintaining the test's intended functionality.
+   */
+  solution: string;
+
+  /** Re-written AST data to fix the compilation error. */
+  function: AutoBeTest.IFunction;
+}