@autobe/agent 0.28.1 → 0.29.1

package/src/orchestrate/interface/utils/OperationValidator.ts

@@ -44,13 +44,26 @@ export namespace OperationValidator {
           `,
         });
       // validate types
-      if (op.requestBody !== null)
+      if (op.requestBody !== null) {
+        validatePrimitiveBody({
+          kind: "requestBody",
+          errors: props.errors,
+          path: `${props.path}[${i}].requestBody`,
+          body: op.requestBody,
+        });
         JsonSchemaValidator.validateKey({
           errors: props.errors,
           path: `${props.path}[${i}].requestBody.typeName`,
           key: op.requestBody.typeName,
         });
+      }
       if (op.responseBody !== null) {
+        validatePrimitiveBody({
+          kind: "responseBody",
+          errors: props.errors,
+          path: `${props.path}[${i}].responseBody`,
+          body: op.responseBody,
+        });
         JsonSchemaValidator.validateKey({
           errors: props.errors,
           path: `${props.path}[${i}].responseBody.typeName`,
@@ -127,4 +140,59 @@ export namespace OperationValidator {
       indexes.push(i);
     });
   };
+
+  const validatePrimitiveBody = (props: {
+    kind: "requestBody" | "responseBody";
+    errors: IValidation.IError[];
+    path: string;
+    body: AutoBeOpenApi.IRequestBody | AutoBeOpenApi.IResponseBody;
+  }): void => {
+    if (props.body.typeName === "undefined" || props.body.typeName === "null")
+      props.errors.push({
+        path: props.path,
+        value: props.body,
+        expected: "null",
+        description: StringUtil.trim`
+          Type ${props.body.typeName} does not mean anything in ${props.kind}.
+
+          Change it to \`null\` if you want to set empty ${props.kind}.
+        `,
+      });
+    else if (
+      props.body.typeName === "number" ||
+      props.body.typeName === "string" ||
+      props.body.typeName === "boolean"
+    )
+      props.errors.push({
+        path: `${props.path}.typeName`,
+        value: props.body.typeName,
+        expected: "An object reference type encapsulating the primitive type",
+        description: StringUtil.trim`
+          Primitive type ${props.body.typeName} is not allowed as the ${props.kind} type.
+
+          If you want to use primitive type in the ${props.kind},
+          encapsulate it in an object reference type. For example, instead of using
+          \`${props.body.typeName}\`, define an object reference type like below:
+
+          - ${props.body.typeName[0].toUpperCase()}${props.body.typeName.slice(1)}Value
+        `,
+      });
+    else if (
+      props.body.typeName === "object" ||
+      props.body.typeName === "any" ||
+      props.body.typeName === "interface"
+    )
+      props.errors.push({
+        path: `${props.path}.typeName`,
+        value: props.body.typeName,
+        expected: "An object reference type",
+        description: StringUtil.trim`
+          Type \`${props.body.typeName}\` is preserved word in the programming languages.
+
+          Change the type name to other one.
+        `,
+      });
+    else if (props.body.typeName.startsWith("I") === false) {
+    }
+  };
 }

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

@@ -0,0 +1,109 @@
+import { StringUtil } from "@autobe/utils";
+import { NamingConvention } from "typia/lib/utils/NamingConvention";
+import { v7 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeState } from "../../../context/AutoBeState";
+import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
+
+export const transformPrismaComponentsHistory = (
+  state: AutoBeState,
+  props: {
+    prefix: string | null;
+    instruction: string;
+  },
+): IAutoBeOrchestrateHistory => {
+  if (state.analyze === null)
+    // unreachable
+    throw new Error("Analyze state is not set.");
+  if (props.prefix) props.prefix = NamingConvention.snake(props.prefix);
+  return {
+    histories: [
+      {
+        id: v7(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: AutoBeSystemPromptConstant.PRISMA_COMPONENT,
+      },
+      {
+        id: v7(),
+        created_at: new Date().toISOString(),
+        type: "assistantMessage",
+        text: StringUtil.trim`
+          ## Requirement Analysis Report
+
+          Here is the requirement analysis report.
+          
+          Call the provided tool function to generate Prisma DB schema
+          referencing below requirement analysis report.
+          
+          \`\`\`json
+          ${JSON.stringify(state.analyze.files)}
+          \`\`\`
+          
+          ## Prefix
+          
+          - Prefix provided by the user: ${props.prefix}
+          
+          The user wants all database schema (table) names to start with the prefix provided below.
+          
+          - DO: Use the provided prefix for all table names
+          - DO: Place special-purpose prefixes like \`mv\` (for materialized views) before the given prefix
+          - DO NOT: Apply prefix if it is \`null\`
+          
+          ## Prefix Example
+          
+          If the prefix is \`shopping\`, then table names are like:
+          
+          - \`shopping_sales\`
+          - \`shopping_sale_options\`
+          
+          In cases where a table is created for performance optimization purposes 
+          (e.g., materialized views), the \`mv_\` prefix must come first. For example:
+          
+          - \`mv_shopping_daily_stats\`
+          
+          ${
+            state.analyze.actors.length > 0
+              ? StringUtil.trim`
+                  ## User Actor Handling
+
+                  The Requirement Analysis Report contains the following user actors: ${state.analyze.actors.join(", ")}
+
+                  **Do not normalize** user actors into a single table.
+                  Instead, create separate tables for each distinct actor mentioned in the requirements.
+
+                  Create separate tables for each actor:
+
+                  ${state.analyze.actors
+                    .map(
+                      (actor) =>
+                        `- ${props.prefix}_${actor.name.toLowerCase()}`,
+                    )
+                    .join("\n")}
+                `
+              : ""
+          }
+
+          ## Database Design Instructions
+
+          The following database-specific instructions were extracted from
+          the user's requirements. These focus on database schema design aspects
+          such as table structure, relationships, constraints, and indexing strategies.
+
+          Follow these instructions when designing namespace components and DB table names. 
+          Carefully distinguish between:
+          - Suggestions or recommendations (consider these as guidance)
+          - Direct specifications or explicit commands (these must be followed exactly)
+          
+          When instructions contain direct specifications or explicit design decisions, 
+          follow them precisely even if you believe you have better alternatives.
+
+          ${props.instruction}
+        `,
+      },
+    ],
+    userMessage:
+      "Design database from the given requirement analysis documents.",
+  };
+};

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

@@ -1,34 +1,23 @@
-import { IAgenticaHistoryJson } from "@agentica/core";
 import { IAutoBePrismaValidation } from "@autobe/interface";
 import { StringUtil } from "@autobe/utils";
 import { v7 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
+import { AutoBePreliminaryController } from "../../common/AutoBePreliminaryController";
 
-export const transformPrismaCorrectHistories = (
-  result: IAutoBePrismaValidation.IFailure,
-): Array<
-  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
-> => {
-  return [
+export const transformPrismaCorrectHistory = (props: {
+  result: IAutoBePrismaValidation.IFailure;
+  preliminary: AutoBePreliminaryController<"analysisFiles" | "prismaSchemas">;
+}): IAutoBeOrchestrateHistory => ({
+  histories: [
     {
       id: v7(),
       created_at: new Date().toISOString(),
       type: "systemMessage",
       text: AutoBeSystemPromptConstant.PRISMA_CORRECT,
     },
-    {
-      id: v7(),
-      created_at: new Date().toISOString(),
-      type: "assistantMessage",
-      text: StringUtil.trim`
-        Here is the Prisma application data what you made:
-        
-        \`\`\`json
-        ${JSON.stringify(result.data)}
-        \`\`\`
-      `,
-    },
+    ...props.preliminary.getHistories(),
     {
       id: v7(),
       created_at: new Date().toISOString(),
@@ -37,9 +26,11 @@ export const transformPrismaCorrectHistories = (
         Below are the list of errors what you have to fix:
         
         \`\`\`json
-        ${JSON.stringify(result.errors)}
+        ${JSON.stringify(props.result.errors)}
         \`\`\`
       `,
     },
-  ];
-};
+  ],
+  userMessage:
+    "Resolve the compilation errors in the provided Prisma schema files.",
+});

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

@@ -0,0 +1,42 @@
+import { AutoBePrisma } from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+import { v7 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
+import { AutoBePreliminaryController } from "../../common/AutoBePreliminaryController";
+
+export const transformPrismaReviewHistory = (props: {
+  preliminary: AutoBePreliminaryController<"analysisFiles" | "prismaSchemas">;
+  component: AutoBePrisma.IComponent;
+}): IAutoBeOrchestrateHistory => ({
+  histories: [
+    {
+      id: v7(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.PRISMA_SCHEMA,
+    },
+    {
+      id: v7(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.PRISMA_REVIEW,
+    },
+    ...props.preliminary.getHistories(),
+    {
+      id: v7(),
+      created_at: new Date().toISOString(),
+      type: "assistantMessage",
+      text: StringUtil.trim`
+        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")}
+      `,
+    },
+  ],
+  userMessage: "Please review the Prisma schema file.",
+});

package/src/orchestrate/prisma/histories/{transformPrismaSchemaHistories.ts → transformPrismaSchemaHistory.ts}

@@ -1,19 +1,17 @@
-import { IAgenticaHistoryJson } from "@agentica/core";
 import { AutoBePrisma } from "@autobe/interface";
 import { StringUtil } from "@autobe/utils";
 import { v7 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
 
-export const transformPrismaSchemaHistories = (props: {
+export const transformPrismaSchemaHistory = (props: {
   analysis: Record<string, string>;
   targetComponent: AutoBePrisma.IComponent;
   otherTables: string[];
   instruction: string;
-}): Array<
-  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
-> => {
-  return [
+}): IAutoBeOrchestrateHistory => ({
+  histories: [
     {
       id: v7(),
       created_at: new Date().toISOString(),
@@ -81,5 +79,6 @@ export const transformPrismaSchemaHistories = (props: {
         \`\`\`
       `,
     },
-  ];
-};
+  ],
+  userMessage: "Make prisma schema file please",
+});

package/src/orchestrate/prisma/orchestratePrisma.ts

@@ -9,6 +9,7 @@ import {
   IAutoBePrismaValidation,
 } from "@autobe/interface";
 import { AutoBePrismaSchemaEvent } from "@autobe/interface/src/events/AutoBePrismaSchemaEvent";
+import { writePrismaApplication } from "@autobe/utils";
 import { ILlmSchema } from "@samchon/openapi";
 import { v7 } from "uuid";
 
@@ -18,7 +19,7 @@ import { IAutoBeFacadeApplicationProps } from "../facade/histories/IAutoBeFacade
 import { orchestratePrismaComponents } from "./orchestratePrismaComponent";
 import { orchestratePrismaCorrect } from "./orchestratePrismaCorrect";
 import { orchestratePrismaReview } from "./orchestratePrismaReview";
-import { orchestratePrismaSchemas } from "./orchestratePrismaSchemas";
+import { orchestratePrismaSchema } from "./orchestratePrismaSchema";
 
 export const orchestratePrisma = async <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
@@ -49,26 +50,19 @@ export const orchestratePrisma = async <Model extends ILlmSchema.Model>(
   ctx.dispatch(componentEvent);
 
   // CONSTRUCT AST DATA
-  const schemaEvents: AutoBePrismaSchemaEvent[] =
-    await orchestratePrismaSchemas(
-      ctx,
-      props.instruction,
-      componentEvent.components,
-    );
+  const schemaEvents: AutoBePrismaSchemaEvent[] = await orchestratePrismaSchema(
+    ctx,
+    props.instruction,
+    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,
     application,
-    reviewSchemas,
     componentEvent.components,
   );
   for (const event of reviewEvents) {
@@ -90,12 +84,13 @@ export const orchestratePrisma = async <Model extends ILlmSchema.Model>(
     ctx,
     application,
   );
-  const finalSchemas: Record<string, string> = await compiler.prisma.write(
-    result.data,
-    "postgres",
-  );
+  const finalSchemas: Record<string, string> = writePrismaApplication({
+    dbms: "postgres",
+    application: result.data,
+  });
 
   // PROPAGATE
+  const compiler: IAutoBeCompiler = await ctx.compiler();
   return ctx.dispatch({
     type: "prismaComplete",
     id: v7(),

package/src/orchestrate/prisma/orchestratePrismaComponent.ts

@@ -7,7 +7,7 @@ import { v7 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
-import { transformPrismaComponentsHistories } from "./histories/transformPrismaComponentsHistories";
+import { transformPrismaComponentsHistory } from "./histories/transformPrismaComponentsHistory";
 import { IAutoBePrismaComponentApplication } from "./structures/IAutoBePrismaComponentApplication";
 
 export async function orchestratePrismaComponents<
@@ -15,7 +15,6 @@ export async function orchestratePrismaComponents<
 >(
   ctx: AutoBeContext<Model>,
   instruction: string,
-  message: string = "Design database from the given requirement analysis documents.",
 ): Promise<AutoBePrismaComponentEvent> {
   const start: Date = new Date();
   const pointer: IPointer<IAutoBePrismaComponentApplication.IProps | null> = {
@@ -24,10 +23,6 @@ export async function orchestratePrismaComponents<
   const prefix: string | null = ctx.state().analyze?.prefix ?? null;
   const { metric, tokenUsage } = await ctx.conversate({
     source: "prismaComponent",
-    histories: transformPrismaComponentsHistories(ctx.state(), {
-      prefix,
-      instruction,
-    }),
     controller: createController({
       model: ctx.model,
       build: (next) => {
@@ -35,7 +30,10 @@ export async function orchestratePrismaComponents<
       },
     }),
     enforceFunctionCall: true,
-    message,
+    ...transformPrismaComponentsHistory(ctx.state(), {
+      instruction,
+      prefix,
+    }),
   });
   if (pointer.value === null)
     throw new Error("Failed to extract files and tables."); // unreachable
@@ -83,12 +81,6 @@ const collection = {
     IAutoBePrismaComponentApplication,
     "chatgpt"
   >(),
-  claude: typia.llm.application<
-    IAutoBePrismaComponentApplication,
-    "claude"
-  >(),
-  gemini: typia.llm.application<
-    IAutoBePrismaComponentApplication,
-    "gemini"
-  >(),
+  claude: typia.llm.application<IAutoBePrismaComponentApplication, "claude">(),
+  gemini: typia.llm.application<IAutoBePrismaComponentApplication, "gemini">(),
 };