@autobe/agent 0.16.1 → 0.18.0

package/src/orchestrate/prisma/{transformPrismaCorrectHistories.ts → histories/transformPrismaCorrectHistories.ts}

@@ -2,7 +2,7 @@ import { IAgenticaHistoryJson } from "@agentica/core";
 import { IAutoBePrismaValidation } from "@autobe/interface";
 import { v4 } from "uuid";
 
-import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
 
 export const transformPrismaCorrectHistories = (
   result: IAutoBePrismaValidation.IFailure,

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/{transformPrismaSchemaHistories.ts → histories/transformPrismaSchemaHistories.ts}

@@ -2,12 +2,12 @@ import { IAgenticaHistoryJson } from "@agentica/core";
 import { AutoBePrisma } from "@autobe/interface";
 import { v4 } from "uuid";
 
-import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
 
 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,90 +1,96 @@
 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 { orchestratePrismaComponents } from "./orchestratePrismaComponent";
 import { orchestratePrismaCorrect } from "./orchestratePrismaCorrect";
+import { orchestratePrismaReview } from "./orchestratePrismaReview";
 import { orchestratePrismaSchemas } from "./orchestratePrismaSchemas";
 
-export const orchestratePrisma =
-  <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) =>
-  async (
-    props: IAutoBeApplicationProps,
-  ): Promise<AutoBePrismaHistory | AutoBeAssistantMessageHistory> => {
-    const start: Date = new Date();
-    ctx.dispatch({
-      type: "prismaStart",
-      created_at: start.toISOString(),
-      reason: props.reason,
-      step: ctx.state().analyze?.step ?? 0,
-    });
+export const orchestratePrisma = async <Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  props: IAutoBeApplicationProps,
+): Promise<AutoBePrismaHistory | AutoBeAssistantMessageHistory> => {
+  const start: Date = new Date();
+  ctx.dispatch({
+    type: "prismaStart",
+    created_at: start.toISOString(),
+    reason: props.reason,
+    step: ctx.state().analyze?.step ?? 0,
+  });
 
-    // COMPONENTS
-    const components:
-      | AutoBeAssistantMessageHistory
-      | AutoBePrismaComponentsEvent = await orchestratePrismaComponents(ctx);
-    if (components.type === "assistantMessage") {
-      ctx.histories().push(components);
-      ctx.dispatch(components);
-      return components;
-    } else ctx.dispatch(components);
+  // COMPONENTS
+  const componentEvent:
+    | AutoBeAssistantMessageHistory
+    | AutoBePrismaComponentsEvent = await orchestratePrismaComponents(ctx);
+  if (componentEvent.type === "assistantMessage")
+    return ctx.assistantMessage(componentEvent);
+  else ctx.dispatch(componentEvent);
 
-    // CONSTRUCT AST DATA
-    const events: AutoBePrismaSchemasEvent[] = await orchestratePrismaSchemas(
-      ctx,
-      components.components,
-    );
+  // CONSTRUCT AST DATA
+  const schemaEvents: AutoBePrismaSchemasEvent[] =
+    await orchestratePrismaSchemas(ctx, componentEvent.components);
+  const application: AutoBePrisma.IApplication = {
+    files: schemaEvents.map((e) => e.file),
+  };
 
-    // VALIDATE
-    const result: IAutoBePrismaValidation = await orchestratePrismaCorrect(
-      ctx,
-      {
-        files: events.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,
+    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;
+    }
+  }
 
-    // COMPILE
-    const compiler: IAutoBeCompiler = await ctx.compiler();
-    const schemas: Record<string, string> = await compiler.prisma.write(
-      result.data,
-      "postgres",
-    );
+  // VALIDATE
+  const result: IAutoBePrismaValidation = await orchestratePrismaCorrect(
+    ctx,
+    application,
+  );
+  const finalSchemas: Record<string, string> = await compiler.prisma.write(
+    result.data,
+    "postgres",
+  );
 
-    // PROPAGATE
-    const history: AutoBePrismaHistory = {
-      type: "prisma",
-      id: v4(),
-      created_at: start.toISOString(),
-      completed_at: new Date().toISOString(),
-      reason: props.reason,
-      description: "",
-      result: result,
-      schemas,
-      compiled: await compiler.prisma.compile({
-        files: schemas,
-      }),
-      step: ctx.state().analyze?.step ?? 0,
-    };
-    ctx.state().prisma = history;
-    ctx.histories().push(history);
-    if (history.result.success === true)
-      ctx.dispatch({
-        type: "prismaComplete",
-        application: history.result.data,
-        schemas: history.schemas,
-        compiled: history.compiled,
-        step: ctx.state().analyze?.step ?? 0,
-        created_at: new Date().toISOString(),
-      } satisfies AutoBePrismaCompleteEvent);
-    return history;
-  };
+  // PROPAGATE
+  return ctx.dispatch({
+    type: "prismaComplete",
+    result,
+    schemas: finalSchemas,
+    compiled: await compiler.prisma.compile({
+      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,10 +1,8 @@
 import {
   AgenticaAssistantMessageHistory,
   IAgenticaController,
-  MicroAgentica,
-  MicroAgenticaHistory,
 } from "@agentica/core";
-import { AutoBeAssistantMessageHistory, AutoBePrisma } from "@autobe/interface";
+import { AutoBeAssistantMessageHistory } from "@autobe/interface";
 import { AutoBePrismaComponentsEvent } from "@autobe/interface/src/events/AutoBePrismaComponentsEvent";
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
 import { IPointer } from "tstl";
@@ -13,49 +11,32 @@ import { v4 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
-import { transformPrismaComponentsHistories } from "./transformPrismaComponentsHistories";
+import { transformPrismaComponentsHistories } from "./histories/transformPrismaComponentsHistories";
+import { IAutoBePrismaComponentApplication } from "./structures/IAutoBePrismaComponentApplication";
 
 export async function orchestratePrismaComponents<
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
-  content: string = "Please extract files and tables from the given documents.",
+  message: string = "Please extract files and tables from the given documents.",
 ): Promise<AutoBeAssistantMessageHistory | AutoBePrismaComponentsEvent> {
   const start: Date = new Date();
-  const pointer: IPointer<IExtractComponentsProps | null> = {
+  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 { histories, tokenUsage } = await ctx.conversate({
+    source: "prismaComponents",
     histories: transformPrismaComponentsHistories(ctx.state(), prefix),
-    controllers: [
-      createApplication({
-        model: ctx.model,
-        build: (next) => {
-          pointer.value ??= {
-            components: [],
-          };
-          pointer.value.components.push(...next.components);
-        },
-      }),
-    ],
+    controller: createController({
+      model: ctx.model,
+      build: (next) => {
+        pointer.value = next;
+      },
+    }),
+    enforceFunctionCall: false,
+    message,
   });
-
-  const histories: MicroAgenticaHistory<Model>[] = await agentica
-    .conversate(content)
-    .finally(() => {
-      const tokenUsage = agentica.getTokenUsage();
-      ctx.usage().record(tokenUsage, ["prisma"]);
-    });
   if (histories.at(-1)?.type === "assistantMessage")
     return {
       ...(histories.at(-1)! as AgenticaAssistantMessageHistory),
@@ -69,20 +50,24 @@ export async function orchestratePrismaComponents<
   return {
     type: "prismaComponents",
     created_at: start.toISOString(),
+    thinking: pointer.value.thinking,
+    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: IExtractComponentsProps) => void;
+  build: (next: IAutoBePrismaComponentApplication.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 Extract Files and Tables",
@@ -91,91 +76,21 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
       extractComponents: (next) => {
         props.build(next);
       },
-    } satisfies IApplication,
+    } satisfies IAutoBePrismaComponentApplication,
   };
 }
 
 const claude = typia.llm.application<
-  IApplication,
-  "claude",
-  { reference: true }
+  IAutoBePrismaComponentApplication,
+  "claude"
 >();
 const collection = {
   chatgpt: typia.llm.application<
-    IApplication,
-    "chatgpt",
-    { reference: true }
+    IAutoBePrismaComponentApplication,
+    "chatgpt"
   >(),
   claude,
   llama: claude,
   deepseek: claude,
   "3.1": claude,
 };
-
-interface IApplication {
-  /**
-   * Extracts and organizes database schema files with their corresponding table
-   * definitions.
-   *
-   * Processes Prisma schema files and maps each file to its contained database
-   * tables, enabling structured organization of schemas across multiple files
-   * for large projects.
-   *
-   * @example
-   *   ```typescript
-   *   application.extractFilesAndTables({
-   *     components: [
-   *       {
-   *         filename: "schema-01-users.prisma",
-   *         tables: ["user", "user_profile"]
-   *       },
-   *       {
-   *         filename: "schema-02-articles.prisma",
-   *         tables: ["article", "attachment_file"]
-   *       }
-   *     ]
-   *   });
-   *   ```;
-   *
-   * @param props - Configuration object containing the file-to-table mapping
-   *   structure
-   */
-  extractComponents(props: IExtractComponentsProps): void;
-}
-
-interface IExtractComponentsProps {
-  /**
-   * Maps Prisma schema filenames to their contained database tables.
-   *
-   * **Structure:**
-   *
-   * - Key: Prisma schema filename with .prisma extension
-   * - Value: Array of table names defined in that file
-   *
-   * **Example:**
-   *
-   * ```typescript
-   * {
-   *   {
-   *     filename: "schema-01-users.prisma",
-   *     tables: ["user", "admin", "moderator", "user_profile", "user_settings"]
-   *   },
-   *   {
-   *     filename: "schema-02-articles.prisma",
-   *     tables: ["article", "article_snapshot"]
-   *   },
-   *   {
-   *     filename: "schema-03-comments.prisma",
-   *     tables: ["comment", "comment_like"]
-   *   }
-   * }
-   * ```
-   *
-   * **Notes:**
-   *
-   * - Table names must match exact Prisma model names (case-sensitive)
-   * - Keep mapping synchronized with actual schema files
-   * - Use consistent naming convention for files
-   */
-  components: AutoBePrisma.IComponent[];
-}