@autobe/agent 0.28.1 → 0.29.1

package/src/orchestrate/prisma/orchestratePrismaCorrect.ts

@@ -1,18 +1,20 @@
 import { IAgenticaController } from "@agentica/core";
 import {
+  AutoBeEventSource,
   AutoBePrisma,
   AutoBePrismaCorrectEvent,
   IAutoBeCompiler,
   IAutoBePrismaValidation,
 } from "@autobe/interface";
-import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
+import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
 import { IPointer } from "tstl";
 import typia from "typia";
 import { v7 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
-import { transformPrismaCorrectHistories } from "./histories/transformPrismaCorrectHistories";
+import { AutoBePreliminaryController } from "../common/AutoBePreliminaryController";
+import { transformPrismaCorrectHistory } from "./histories/transformPrismaCorrectHistory";
 import { IAutoBePrismaCorrectApplication } from "./structures/IAutoBePrismaCorrectApplication";
 
 export function orchestratePrismaCorrect<Model extends ILlmSchema.Model>(
@@ -102,6 +104,7 @@ async function process<Model extends ILlmSchema.Model>(
     else failure = result;
   }
   return {
+    type: "complete",
     planning: plannings.join("\n\n"),
     models: Object.values(models),
     correction,
@@ -112,91 +115,153 @@ async function execute<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   failure: IAutoBePrismaValidation.IFailure,
 ): Promise<IExecutionResult> {
-  // PREPARE AGENTICA
-  const pointer: IPointer<IAutoBePrismaCorrectApplication.IProps | null> = {
-    value: null,
-  };
-  const { metric, tokenUsage } = await ctx.conversate({
-    source: "prismaCorrect",
-    histories: transformPrismaCorrectHistories(failure),
-    controller: createController({
-      model: ctx.model,
-      build: (next) => {
-        pointer.value = next;
-      },
-    }),
-    enforceFunctionCall: true,
-    message:
-      "Resolve the compilation errors in the provided Prisma schema files.",
+  const preliminary: AutoBePreliminaryController<
+    "analysisFiles" | "prismaSchemas"
+  > = new AutoBePreliminaryController({
+    application: typia.json.application<IAutoBePrismaCorrectApplication>(),
+    source: SOURCE,
+    kinds: ["analysisFiles", "prismaSchemas"],
+    state: ctx.state(),
+    all: {
+      prismaSchemas: failure.data.files.map((f) => f.models).flat(),
+    },
+    local: {
+      prismaSchemas: Array.from(
+        new Set(failure.errors.map((e) => e.table).filter((t) => t !== null)),
+      )
+        .map((table: string): AutoBePrisma.IModel | undefined =>
+          failure.data.files
+            .map((f) => f.models)
+            .flat()
+            .find((m) => m.name === table),
+        )
+        .filter((m) => m !== undefined),
+    },
   });
-  if (pointer.value === null)
-    throw new Error(
-      "Unreachable error: PrismaCompilerAgent.pointer.value is null",
-    );
-  const correction: AutoBePrisma.IApplication = {
-    files: failure.data.files.map((file) => ({
-      filename: file.filename,
-      namespace: file.namespace,
-      models: file.models.map((model) => {
-        const newbie = pointer.value?.models.find((m) => m.name === model.name);
-        return newbie ?? model;
+  return await preliminary.orchestrate(ctx, async (out) => {
+    const pointer: IPointer<IAutoBePrismaCorrectApplication.IComplete | null> =
+      {
+        value: null,
+      };
+    const result: AutoBeContext.IResult<Model> = await ctx.conversate({
+      source: SOURCE,
+      controller: createController({
+        preliminary,
+        model: ctx.model,
+        build: (next) => {
+          pointer.value = next;
+        },
       }),
-    })),
-  };
-  ctx.dispatch({
-    type: "prismaCorrect",
-    id: v7(),
-    failure,
-    planning: pointer.value.planning,
-    correction: correction,
-    metric,
-    tokenUsage,
-    step: ctx.state().analyze?.step ?? 0,
-    created_at: new Date().toISOString(),
-  } satisfies AutoBePrismaCorrectEvent);
-  return {
-    ...pointer.value,
-    correction,
-  };
+      enforceFunctionCall: true,
+      ...transformPrismaCorrectHistory({
+        preliminary,
+        result: failure,
+      }),
+    });
+    if (pointer.value !== null) {
+      const correction: AutoBePrisma.IApplication = {
+        files: failure.data.files.map((file) => ({
+          filename: file.filename,
+          namespace: file.namespace,
+          models: file.models.map((model) => {
+            const newbie = pointer.value?.models.find(
+              (m) => m.name === model.name,
+            );
+            return newbie ?? model;
+          }),
+        })),
+      };
+      ctx.dispatch({
+        type: SOURCE,
+        id: v7(),
+        failure,
+        planning: pointer.value.planning,
+        correction: correction,
+        metric: result.metric,
+        tokenUsage: result.tokenUsage,
+        step: ctx.state().analyze?.step ?? 0,
+        created_at: new Date().toISOString(),
+      } satisfies AutoBePrismaCorrectEvent);
+      return out(result)({
+        ...pointer.value,
+        correction,
+      });
+    }
+    return out(result)(null);
+  });
 }
 
+interface IExecutionResult extends IAutoBePrismaCorrectApplication.IComplete {
+  correction: AutoBePrisma.IApplication;
+}
+
+const getTableCount = (failure: IAutoBePrismaValidation.IFailure): number => {
+  const unique: Set<string | null> = new Set(
+    failure.errors.map((error) => error.table ?? null),
+  );
+  return unique.size;
+};
+
 function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
-  build: (next: IAutoBePrismaCorrectApplication.IProps) => void;
+  preliminary: AutoBePreliminaryController<"analysisFiles" | "prismaSchemas">;
+  build: (next: IAutoBePrismaCorrectApplication.IComplete) => void;
 }): IAgenticaController.IClass<Model> {
   assertSchemaModel(props.model);
+  const validate: Validator = (input) => {
+    const result =
+      typia.validate<IAutoBePrismaCorrectApplication.IProps>(input);
+    if (result.success === false || result.data.request.type === "complete")
+      return result;
+    return props.preliminary.validate({
+      thinking: result.data.thinking,
+      request: result.data.request,
+    });
+  };
   const application: ILlmApplication<Model> = collection[
     props.model === "chatgpt"
       ? "chatgpt"
       : props.model === "gemini"
         ? "gemini"
         : "claude"
-  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
+  ](
+    validate,
+  ) satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
   return {
     protocol: "class",
-    name: "Prisma Compiler",
+    name: SOURCE satisfies AutoBeEventSource,
     application,
     execute: {
-      correctPrismaSchemaFiles: (next) => {
-        props.build(next);
+      process: (next) => {
+        if (next.request.type === "complete") props.build(next.request);
       },
     } satisfies IAutoBePrismaCorrectApplication,
   };
 }
 
-const getTableCount = (failure: IAutoBePrismaValidation.IFailure): number => {
-  const unique: Set<string | null> = new Set(
-    failure.errors.map((error) => error.table ?? null),
-  );
-  return unique.size;
-};
-
 const collection = {
-  chatgpt: typia.llm.application<IAutoBePrismaCorrectApplication, "chatgpt">(),
-  claude: typia.llm.application<IAutoBePrismaCorrectApplication, "claude">(),
-  gemini: typia.llm.application<IAutoBePrismaCorrectApplication, "gemini">(),
+  chatgpt: (validate: Validator) =>
+    typia.llm.application<IAutoBePrismaCorrectApplication, "chatgpt">({
+      validate: {
+        process: validate,
+      },
+    }),
+  claude: (validate: Validator) =>
+    typia.llm.application<IAutoBePrismaCorrectApplication, "claude">({
+      validate: {
+        process: validate,
+      },
+    }),
+  gemini: (validate: Validator) =>
+    typia.llm.application<IAutoBePrismaCorrectApplication, "gemini">({
+      validate: {
+        process: validate,
+      },
+    }),
 };
 
-interface IExecutionResult extends IAutoBePrismaCorrectApplication.IProps {
-  correction: AutoBePrisma.IApplication;
-}
+type Validator = (
+  input: unknown,
+) => IValidation<IAutoBePrismaCorrectApplication.IProps>;
+
+const SOURCE = "prismaCorrect" satisfies AutoBeEventSource;

package/src/orchestrate/prisma/orchestratePrismaReview.ts

@@ -1,7 +1,11 @@
 import { IAgenticaController } from "@agentica/core";
-import { AutoBePrisma, AutoBeProgressEventBase } from "@autobe/interface";
+import {
+  AutoBeEventSource,
+  AutoBePrisma,
+  AutoBeProgressEventBase,
+} from "@autobe/interface";
 import { AutoBePrismaReviewEvent } from "@autobe/interface/src/events/AutoBePrismaReviewEvent";
-import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
+import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
 import { IPointer } from "tstl";
 import typia from "typia";
 import { v7 } from "uuid";
@@ -9,13 +13,13 @@ import { v7 } from "uuid";
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { executeCachedBatch } from "../../utils/executeCachedBatch";
-import { transformPrismaReviewHistories } from "./histories/transformPrismaReviewHistories";
+import { AutoBePreliminaryController } from "../common/AutoBePreliminaryController";
+import { transformPrismaReviewHistory } from "./histories/transformPrismaReviewHistory";
 import { IAutoBePrismaReviewApplication } from "./structures/IAutoBePrismaReviewApplication";
 
 export async function orchestratePrismaReview<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   application: AutoBePrisma.IApplication,
-  schemas: Record<string, string>,
   componentList: AutoBePrisma.IComponent[],
 ): Promise<AutoBePrismaReviewEvent[]> {
   const progress: AutoBeProgressEventBase = {
@@ -24,11 +28,11 @@ export async function orchestratePrismaReview<Model extends ILlmSchema.Model>(
   };
   return (
     await executeCachedBatch(
+      ctx,
       componentList.map((component) => async (promptCacheKey) => {
         try {
           return await step(ctx, {
             application,
-            schemas,
             component,
             progress,
             promptCacheKey,
@@ -46,90 +50,142 @@ async function step<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   props: {
     application: AutoBePrisma.IApplication;
-    schemas: Record<string, string>;
     component: AutoBePrisma.IComponent;
     progress: AutoBeProgressEventBase;
     promptCacheKey: string;
   },
 ): Promise<AutoBePrismaReviewEvent> {
   const start: Date = new Date();
-  const pointer: IPointer<IAutoBePrismaReviewApplication.IProps | null> = {
-    value: null,
-  };
-  const { metric, tokenUsage } = await ctx.conversate({
-    source: "prismaReview",
-    histories: transformPrismaReviewHistories({
-      analysis:
-        ctx
-          .state()
-          .analyze?.files.map((file) => ({ [file.filename]: file.content }))
-          .reduce((acc, cur) => {
-            return Object.assign(acc, cur);
-          }, {}) ?? {},
-      application: props.application,
-      schemas: props.schemas,
-      component: props.component,
-    }),
-    controller: createController(ctx, {
-      build: (next) => {
-        pointer.value = next;
-      },
-    }),
-    enforceFunctionCall: true,
-    promptCacheKey: props.promptCacheKey,
-    message: "Please review the Prisma schema file.",
+  const preliminary: AutoBePreliminaryController<
+    "analysisFiles" | "prismaSchemas"
+  > = new AutoBePreliminaryController({
+    application: typia.json.application<IAutoBePrismaReviewApplication>(),
+    source: SOURCE,
+    kinds: ["analysisFiles", "prismaSchemas"],
+    state: ctx.state(),
+    all: {
+      prismaSchemas: props.application.files.map((f) => f.models).flat(),
+    },
+    local: {
+      prismaSchemas: ((): AutoBePrisma.IModel[] => {
+        const file: AutoBePrisma.IFile | undefined =
+          props.application.files.find(
+            (f) => f.filename === props.component.filename,
+          );
+        if (file === undefined) return [];
+        return props.component.tables
+          .map((table) => file.models.find((m) => m.name === table))
+          .filter((m) => m !== undefined);
+      })(),
+    },
+  });
+  return await preliminary.orchestrate(ctx, async (out) => {
+    const pointer: IPointer<IAutoBePrismaReviewApplication.IComplete | null> = {
+      value: null,
+    };
+    const result: AutoBeContext.IResult<Model> = await ctx.conversate({
+      source: SOURCE,
+      controller: createController(ctx, {
+        preliminary,
+        build: (next) => {
+          pointer.value = next;
+        },
+      }),
+      enforceFunctionCall: true,
+      promptCacheKey: props.promptCacheKey,
+      ...transformPrismaReviewHistory({
+        component: props.component,
+        preliminary,
+      }),
+    });
+    if (pointer.value !== null) {
+      const event: AutoBePrismaReviewEvent = {
+        type: SOURCE,
+        id: v7(),
+        created_at: start.toISOString(),
+        filename: props.component.filename,
+        review: pointer.value.review,
+        plan: pointer.value.plan,
+        modifications: pointer.value.modifications,
+        metric: result.metric,
+        tokenUsage: result.tokenUsage,
+        completed: ++props.progress.completed,
+        total: props.progress.total,
+        step: ctx.state().analyze?.step ?? 0,
+      };
+      ctx.dispatch(event);
+      return out(result)(event);
+    }
+    return out(result)(null);
   });
-  if (pointer.value === null)
-    throw new Error("Failed to review the Prisma schema.");
-
-  const event: AutoBePrismaReviewEvent = {
-    type: "prismaReview",
-    id: v7(),
-    created_at: start.toISOString(),
-    filename: props.component.filename,
-    review: pointer.value.review,
-    plan: pointer.value.plan,
-    modifications: pointer.value.modifications,
-    metric,
-    tokenUsage,
-    completed: ++props.progress.completed,
-    total: props.progress.total,
-    step: ctx.state().analyze?.step ?? 0,
-  };
-  ctx.dispatch(event);
-  return event;
 }
 
 function createController<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   props: {
-    build: (next: IAutoBePrismaReviewApplication.IProps) => void;
+    preliminary: AutoBePreliminaryController<"analysisFiles" | "prismaSchemas">;
+    build: (next: IAutoBePrismaReviewApplication.IComplete) => void;
   },
 ): IAgenticaController.IClass<Model> {
   assertSchemaModel(ctx.model);
 
+  const validate = (
+    input: unknown,
+  ): IValidation<IAutoBePrismaReviewApplication.IProps> => {
+    const result: IValidation<IAutoBePrismaReviewApplication.IProps> =
+      typia.validate<IAutoBePrismaReviewApplication.IProps>(input);
+    if (result.success === false || result.data.request.type === "complete")
+      return result;
+    return props.preliminary.validate({
+      thinking: result.data.thinking,
+      request: result.data.request,
+    });
+  };
+
   const application: ILlmApplication<Model> = collection[
     ctx.model === "chatgpt"
       ? "chatgpt"
       : ctx.model === "gemini"
         ? "gemini"
         : "claude"
-  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
-
+  ](
+    validate,
+  ) satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
   return {
     protocol: "class",
-    name: "Prisma Schema Review",
+    name: SOURCE,
     application,
     execute: {
-      reviewSchemaFile: (next) => {
-        props.build(next);
+      process: (next) => {
+        if (next.request.type === "complete") props.build(next.request);
       },
     } satisfies IAutoBePrismaReviewApplication,
   };
 }
 
 const collection = {
-  chatgpt: typia.llm.application<IAutoBePrismaReviewApplication, "chatgpt">(),
-  claude: typia.llm.application<IAutoBePrismaReviewApplication, "claude">(),
-  gemini: typia.llm.application<IAutoBePrismaReviewApplication, "gemini">(),
+  chatgpt: (validate: Validator) =>
+    typia.llm.application<IAutoBePrismaReviewApplication, "chatgpt">({
+      validate: {
+        process: validate,
+      },
+    }),
+  claude: (validate: Validator) =>
+    typia.llm.application<IAutoBePrismaReviewApplication, "claude">({
+      validate: {
+        process: validate,
+      },
+    }),
+  gemini: (validate: Validator) =>
+    typia.llm.application<IAutoBePrismaReviewApplication, "gemini">({
+      validate: {
+        process: validate,
+      },
+    }),
 };
+
+type Validator = (
+  input: unknown,
+) => IValidation<IAutoBePrismaReviewApplication.IProps>;
+
+const SOURCE = "prismaReview" satisfies AutoBeEventSource;