@autobe/agent 0.17.1 → 0.19.1

package/src/orchestrate/prisma/histories/transformPrismaReviewHistories.ts

@@ -0,0 +1,66 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBePrisma } from "@autobe/interface";
+import { v4 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+
+export const transformPrismaReviewHistories = (props: {
+  analysis: Record<string, string>;
+  application: AutoBePrisma.IApplication;
+  schemas: Record<string, string>;
+  component: AutoBePrisma.IComponent;
+}): Array<
+  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+> => {
+  return [
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.PRISMA_SCHEMA,
+    },
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "assistantMessage",
+      text: [
+        "Here is the requirement analysis report given by the user:",
+        "",
+        "```json",
+        JSON.stringify(props.analysis),
+        "```",
+        "",
+        "Reading the requirement analysis report, you AI made below AST definition for the database design:",
+        "",
+        "```json",
+        JSON.stringify(props.application),
+        "```",
+        "",
+        "And here are the Prisma schema files generated (compiled) from the above AST:",
+        "",
+        "```prisma",
+        JSON.stringify(props.schemas),
+        "```",
+      ].join("\n"),
+    },
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.PRISMA_REVIEW,
+    },
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "assistantMessage",
+      text: [
+        `Now, please review the tables in the "${props.component.namespace}" namespace.`,
+        "",
+        "Focus your review exclusively on these tables.",
+        "",
+        "**Tables in this namespace:**",
+        ...props.component.tables.map((table) => `- ${table}`),
+      ].join("\n"),
+    },
+  ];
+};

package/src/orchestrate/prisma/histories/transformPrismaSchemaHistories.ts

@@ -7,7 +7,7 @@ import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromp
 export const transformPrismaSchemaHistories = (
   requirementAnalysisReport: Record<string, string>,
   targetComponent: AutoBePrisma.IComponent,
-  otherComponents: AutoBePrisma.IComponent[],
+  otherTables: string[],
 ): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
 > => {
@@ -28,8 +28,8 @@ export const transformPrismaSchemaHistories = (
         "```",
         JSON.stringify({
           requirementAnalysisReport,
-          otherComponents,
           targetComponent,
+          otherTables,
         }),
         "```",
       ].join("\n"),

package/src/orchestrate/prisma/orchestratePrisma.ts

@@ -1,25 +1,40 @@
 import {
   AutoBeAssistantMessageHistory,
+  AutoBePrisma,
   AutoBePrismaCompleteEvent,
   AutoBePrismaComponentsEvent,
   AutoBePrismaHistory,
+  AutoBePrismaReviewEvent,
   IAutoBeCompiler,
   IAutoBePrismaValidation,
 } from "@autobe/interface";
 import { AutoBePrismaSchemasEvent } from "@autobe/interface/src/events/AutoBePrismaSchemasEvent";
 import { ILlmSchema } from "@samchon/openapi";
+import { v4 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
+import { predicateStateMessage } from "../../utils/predicateStateMessage";
 import { orchestratePrismaComponents } from "./orchestratePrismaComponent";
 import { orchestratePrismaCorrect } from "./orchestratePrismaCorrect";
+import { orchestratePrismaReview } from "./orchestratePrismaReview";
 import { orchestratePrismaSchemas } from "./orchestratePrismaSchemas";
 
 export const orchestratePrisma = async <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   props: IAutoBeApplicationProps,
 ): Promise<AutoBePrismaHistory | AutoBeAssistantMessageHistory> => {
+  // PREDICATION
   const start: Date = new Date();
+  const predicate: string | null = predicateStateMessage(ctx.state(), "prisma");
+  if (predicate !== null)
+    return ctx.assistantMessage({
+      type: "assistantMessage",
+      id: v4(),
+      created_at: start.toISOString(),
+      text: predicate,
+      completed_at: new Date().toISOString(),
+    });
   ctx.dispatch({
     type: "prismaStart",
     created_at: start.toISOString(),
@@ -28,27 +43,49 @@ export const orchestratePrisma = async <Model extends ILlmSchema.Model>(
   });
 
   // COMPONENTS
-  const components:
-    | AutoBeAssistantMessageHistory
-    | AutoBePrismaComponentsEvent = await orchestratePrismaComponents(ctx);
-  if (components.type === "assistantMessage")
-    return ctx.assistantMessage(components);
-  else ctx.dispatch(components);
+  const componentEvent: AutoBePrismaComponentsEvent =
+    await orchestratePrismaComponents(ctx);
+  ctx.dispatch(componentEvent);
 
   // CONSTRUCT AST DATA
-  const events: AutoBePrismaSchemasEvent[] = await orchestratePrismaSchemas(
+  const schemaEvents: AutoBePrismaSchemasEvent[] =
+    await orchestratePrismaSchemas(ctx, componentEvent.components);
+  const application: AutoBePrisma.IApplication = {
+    files: schemaEvents.map((e) => e.file),
+  };
+
+  // REVIEW
+  const compiler: IAutoBeCompiler = await ctx.compiler();
+  const reviewSchemas: Record<string, string> = await compiler.prisma.write(
+    application,
+    "postgres",
+  );
+  const reviewEvents: AutoBePrismaReviewEvent[] = await orchestratePrismaReview(
     ctx,
-    components.components,
+    application,
+    reviewSchemas,
+    componentEvent.components,
   );
+  for (const event of reviewEvents) {
+    const file: AutoBePrisma.IFile | undefined = application.files.find(
+      (f) => f.filename === event.filename,
+    );
+    if (file === undefined) continue;
+    for (const modification of event.modifications) {
+      const index: number = file.models.findIndex(
+        (m) => m.name === modification.name,
+      );
+      if (index === -1) file.models.push(modification);
+      else file.models[index] = modification;
+    }
+  }
 
   // VALIDATE
-  const result: IAutoBePrismaValidation = await orchestratePrismaCorrect(ctx, {
-    files: events.map((e) => e.file),
-  });
-
-  // COMPILE
-  const compiler: IAutoBeCompiler = await ctx.compiler();
-  const schemas: Record<string, string> = await compiler.prisma.write(
+  const result: IAutoBePrismaValidation = await orchestratePrismaCorrect(
+    ctx,
+    application,
+  );
+  const finalSchemas: Record<string, string> = await compiler.prisma.write(
     result.data,
     "postgres",
   );
@@ -57,11 +94,12 @@ export const orchestratePrisma = async <Model extends ILlmSchema.Model>(
   return ctx.dispatch({
     type: "prismaComplete",
     result,
-    schemas,
+    schemas: finalSchemas,
     compiled: await compiler.prisma.compile({
-      files: schemas,
+      files: finalSchemas,
     }),
     step: ctx.state().analyze?.step ?? 0,
+    elapsed: new Date().getTime() - start.getTime(),
     created_at: new Date().toISOString(),
   } satisfies AutoBePrismaCompleteEvent);
 };

package/src/orchestrate/prisma/orchestratePrismaComponent.ts

@@ -1,15 +1,8 @@
-import {
-  AgenticaAssistantMessageHistory,
-  IAgenticaController,
-  MicroAgentica,
-  MicroAgenticaHistory,
-} from "@agentica/core";
-import { AutoBeAssistantMessageHistory } from "@autobe/interface";
+import { IAgenticaController } from "@agentica/core";
 import { AutoBePrismaComponentsEvent } from "@autobe/interface/src/events/AutoBePrismaComponentsEvent";
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
 import { IPointer } from "tstl";
 import typia from "typia";
-import { v4 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
@@ -20,49 +13,27 @@ export async function orchestratePrismaComponents<
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
-  content: string = "Please extract files and tables from the given documents.",
-): Promise<AutoBeAssistantMessageHistory | AutoBePrismaComponentsEvent> {
+  message: string = "Design database from the given requirement analysis documents.",
+): Promise<AutoBePrismaComponentsEvent> {
   const start: Date = new Date();
   const pointer: IPointer<IAutoBePrismaComponentApplication.IProps | null> = {
     value: null,
   };
   const prefix: string | null = ctx.state().analyze?.prefix ?? null;
-  const agentica: MicroAgentica<Model> = new MicroAgentica({
-    model: ctx.model,
-    vendor: ctx.vendor,
-    config: {
-      ...(ctx.config ?? {}),
-      executor: {
-        describe: null,
-      },
-    },
+  const { tokenUsage } = await ctx.conversate({
+    source: "prismaComponents",
     histories: transformPrismaComponentsHistories(ctx.state(), prefix),
-    controllers: [
-      createApplication({
-        model: ctx.model,
-        build: (next) => {
-          pointer.value = next;
-        },
-      }),
-    ],
+    controller: createController({
+      model: ctx.model,
+      build: (next) => {
+        pointer.value = next;
+      },
+    }),
+    enforceFunctionCall: true,
+    message,
   });
-
-  const histories: MicroAgenticaHistory<Model>[] = await agentica
-    .conversate(content)
-    .finally(() => {
-      const tokenUsage = agentica.getTokenUsage().aggregate;
-      ctx.usage().record(tokenUsage, ["prisma"]);
-    });
-  if (histories.at(-1)?.type === "assistantMessage")
-    return {
-      ...(histories.at(-1)! as AgenticaAssistantMessageHistory),
-      created_at: start.toISOString(),
-      completed_at: new Date().toISOString(),
-      id: v4(),
-    } satisfies AutoBeAssistantMessageHistory;
-  else if (pointer.value === null) {
+  if (pointer.value === null)
     throw new Error("Failed to extract files and tables."); // unreachable
-  }
   return {
     type: "prismaComponents",
     created_at: start.toISOString(),
@@ -70,11 +41,12 @@ export async function orchestratePrismaComponents<
     review: pointer.value.review,
     decision: pointer.value.decision,
     components: pointer.value.components,
+    tokenUsage,
     step: ctx.state().analyze?.step ?? 0,
   };
 }
 
-function createApplication<Model extends ILlmSchema.Model>(props: {
+function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
   build: (next: IAutoBePrismaComponentApplication.IProps) => void;
 }): IAgenticaController.IClass<Model> {
@@ -82,7 +54,7 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
 
   const application: ILlmApplication<Model> = collection[
     props.model
-  ] as unknown as ILlmApplication<Model>;
+  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
   return {
     protocol: "class",
     name: "Prisma Extract Files and Tables",
@@ -97,14 +69,12 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
 
 const claude = typia.llm.application<
   IAutoBePrismaComponentApplication,
-  "claude",
-  { reference: true }
+  "claude"
 >();
 const collection = {
   chatgpt: typia.llm.application<
     IAutoBePrismaComponentApplication,
-    "chatgpt",
-    { reference: true }
+    "chatgpt"
   >(),
   claude,
   llama: claude,

package/src/orchestrate/prisma/orchestratePrismaCorrect.ts

@@ -1,6 +1,7 @@
-import { IAgenticaController, MicroAgentica } from "@agentica/core";
+import { IAgenticaController } from "@agentica/core";
 import {
   AutoBePrisma,
+  AutoBePrismaCorrectEvent,
   IAutoBeCompiler,
   IAutoBePrismaValidation,
 } from "@autobe/interface";
@@ -10,7 +11,6 @@ import typia from "typia";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
-import { enforceToolCall } from "../../utils/enforceToolCall";
 import { transformPrismaCorrectHistories } from "./histories/transformPrismaCorrectHistories";
 import { IAutoBePrismaCorrectApplication } from "./structures/IAutoBePrismaCorrectApplication";
 
@@ -27,10 +27,10 @@ export function orchestratePrismaCorrect<Model extends ILlmSchema.Model>(
       return true;
     });
   application.files = application.files.filter((f) => f.models.length !== 0);
-  return step(ctx, application, life);
+  return iterate(ctx, application, life);
 }
 
-async function step<Model extends ILlmSchema.Model>(
+async function iterate<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   application: AutoBePrisma.IApplication,
   life: number,
@@ -57,82 +57,114 @@ async function step<Model extends ILlmSchema.Model>(
     step: ctx.state().analyze?.step ?? 0,
     created_at: new Date().toISOString(),
   });
+  const next: IExecutionResult = await process(ctx, result);
+  return iterate(ctx, next.correction, life - 1);
+}
+
+async function process<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  failure: IAutoBePrismaValidation.IFailure,
+  capacity: number = 8,
+): Promise<IExecutionResult> {
+  const count: number = getTableCount(failure);
+  if (count <= capacity) return execute(ctx, failure);
 
+  let correction: AutoBePrisma.IApplication = failure.data;
+  const volume: number = Math.ceil(count / capacity);
+  const plannings: string[] = [];
+  const models: Record<string, AutoBePrisma.IModel> = {};
+  let i: number = 0;
+
+  while (i++ < volume && failure.errors.length !== 0) {
+    const next: IExecutionResult = await execute(ctx, {
+      ...failure,
+      errors: (() => {
+        const unique: Set<string | null> = new Set();
+        const errors: IAutoBePrismaValidation.IError[] = [];
+        for (const err of failure.errors) {
+          unique.add(err.table ?? null);
+          if (unique.size > capacity) break;
+          else errors.push(err);
+        }
+        return errors;
+      })(),
+    });
+    plannings.push(next.planning);
+    for (const m of next.models) models[m.name] = m;
+
+    const compiler: IAutoBeCompiler = await ctx.compiler();
+    const result: IAutoBePrismaValidation = await compiler.prisma.validate(
+      next.correction,
+    );
+    correction = next.correction;
+    if (result.success === true) break;
+    else failure = result;
+  }
+  return {
+    planning: plannings.join("\n\n"),
+    models: Object.values(models),
+    correction,
+  };
+}
+
+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 agentica: MicroAgentica<Model> = new MicroAgentica({
-    model: ctx.model,
-    vendor: ctx.vendor,
-    config: {
-      ...(ctx.config ?? {}),
-      executor: {
-        describe: null,
+  const { tokenUsage } = await ctx.conversate({
+    source: "prismaCorrect",
+    histories: transformPrismaCorrectHistories(failure),
+    controller: createController({
+      model: ctx.model,
+      build: (next) => {
+        pointer.value = next;
       },
-    },
-    histories: transformPrismaCorrectHistories(result),
-    controllers: [
-      createApplication({
-        model: ctx.model,
-        build: (next) => {
-          pointer.value = next;
-        },
-      }),
-    ],
-  });
-  enforceToolCall(agentica);
-
-  // REQUEST CORRECTION
-  await agentica
-    .conversate(
+    }),
+    enforceFunctionCall: true,
+    message:
       "Resolve the compilation errors in the provided Prisma schema files.",
-    )
-    .finally(() => {
-      const tokenUsage = agentica.getTokenUsage().aggregate;
-      ctx.usage().record(tokenUsage, ["prisma"]);
-    });
-  if (pointer.value === null) {
-    console.error(
+  });
+  if (pointer.value === null)
+    throw new Error(
       "Unreachable error: PrismaCompilerAgent.pointer.value is null",
     );
-    return result; // unreachable
-  }
-
   const correction: AutoBePrisma.IApplication = {
-    files: application.files.map((file) => ({
+    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);
+        const newbie = pointer.value?.models.find((m) => m.name === model.name);
         return newbie ?? model;
       }),
     })),
   };
   ctx.dispatch({
     type: "prismaCorrect",
-    failure: result,
-    correction,
+    failure,
     planning: pointer.value.planning,
+    correction: correction,
+    tokenUsage,
     step: ctx.state().analyze?.step ?? 0,
     created_at: new Date().toISOString(),
-  });
-  return step(
-    ctx,
-    {
-      files: correction.files,
-    },
-    life - 1,
-  );
+  } satisfies AutoBePrismaCorrectEvent);
+  return {
+    ...pointer.value,
+    correction,
+  };
 }
 
-function createApplication<Model extends ILlmSchema.Model>(props: {
+function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
   build: (next: IAutoBePrismaCorrectApplication.IProps) => void;
 }): IAgenticaController.IClass<Model> {
   assertSchemaModel(props.model);
   const application: ILlmApplication<Model> = collection[
     props.model
-  ] as unknown as ILlmApplication<Model>;
+  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
   return {
     protocol: "class",
     name: "Prisma Compiler",
@@ -145,19 +177,25 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
   };
 }
 
+const getTableCount = (failure: IAutoBePrismaValidation.IFailure): number => {
+  const unique: Set<string | null> = new Set(
+    failure.errors.map((error) => error.table ?? null),
+  );
+  return unique.size;
+};
+
 const claude = typia.llm.application<
   IAutoBePrismaCorrectApplication,
-  "claude",
-  { reference: true }
+  "claude"
 >();
 const collection = {
-  chatgpt: typia.llm.application<
-    IAutoBePrismaCorrectApplication,
-    "chatgpt",
-    { reference: true }
-  >(),
+  chatgpt: typia.llm.application<IAutoBePrismaCorrectApplication, "chatgpt">(),
   claude,
   llama: claude,
   deepseek: claude,
   "3.1": claude,
 };
+
+interface IExecutionResult extends IAutoBePrismaCorrectApplication.IProps {
+  correction: AutoBePrisma.IApplication;
+}

package/src/orchestrate/prisma/orchestratePrismaReview.ts

@@ -0,0 +1,124 @@
+import { IAgenticaController } from "@agentica/core";
+import { AutoBePrisma, AutoBeProgressEventBase } from "@autobe/interface";
+import { AutoBePrismaReviewEvent } from "@autobe/interface/src/events/AutoBePrismaReviewEvent";
+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 { transformPrismaReviewHistories } from "./histories/transformPrismaReviewHistories";
+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 = {
+    completed: 0,
+    total: componentList.length,
+  };
+  return (
+    await Promise.all(
+      componentList.map(async (component) => {
+        try {
+          return await step(ctx, application, schemas, component, progress);
+        } catch {
+          ++progress.completed;
+          return null;
+        }
+      }),
+    )
+  ).filter((v) => v !== null);
+}
+
+async function step<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  application: AutoBePrisma.IApplication,
+  schemas: Record<string, string>,
+  component: AutoBePrisma.IComponent,
+  progress: AutoBeProgressEventBase,
+): Promise<AutoBePrismaReviewEvent> {
+  const start: Date = new Date();
+  const pointer: IPointer<IAutoBePrismaReviewApplication.IProps | null> = {
+    value: null,
+  };
+  const { 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,
+      schemas,
+      component,
+    }),
+    controller: createController(ctx, {
+      build: (next) => {
+        pointer.value = next;
+      },
+    }),
+    enforceFunctionCall: true,
+    message: "Please review the Prisma schema file.",
+  });
+  if (pointer.value === null)
+    throw new Error("Failed to review the Prisma schema.");
+
+  const event: AutoBePrismaReviewEvent = {
+    type: "prismaReview",
+    created_at: start.toISOString(),
+    filename: component.filename,
+    review: pointer.value.review,
+    plan: pointer.value.plan,
+    modifications: pointer.value.modifications,
+    tokenUsage,
+    completed: ++progress.completed,
+    total: 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;
+  },
+): IAgenticaController.IClass<Model> {
+  assertSchemaModel(ctx.model);
+
+  const application: ILlmApplication<Model> = collection[
+    ctx.model
+  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
+
+  return {
+    protocol: "class",
+    name: "Prisma Schema Review",
+    application,
+    execute: {
+      reviewSchemaFile: (next) => {
+        props.build(next);
+      },
+    } satisfies IAutoBePrismaReviewApplication,
+  };
+}
+
+const claude = typia.llm.application<
+  IAutoBePrismaReviewApplication,
+  "claude"
+>();
+
+const collection = {
+  chatgpt: typia.llm.application<IAutoBePrismaReviewApplication, "chatgpt">(),
+  claude,
+  llama: claude,
+  deepseek: claude,
+  "3.1": claude,
+};