@autobe/agent 0.17.1 → 0.19.1

package/src/orchestrate/prisma/orchestratePrismaSchemas.ts

@@ -1,52 +1,37 @@
-import { IAgenticaController, MicroAgentica } from "@agentica/core";
+import { IAgenticaController } from "@agentica/core";
 import { AutoBePrisma } from "@autobe/interface";
 import { AutoBePrismaSchemasEvent } from "@autobe/interface/src/events/AutoBePrismaSchemasEvent";
-import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
+import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
 import { IPointer } from "tstl";
 import typia from "typia";
 
-// import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
-import { enforceToolCall } from "../../utils/enforceToolCall";
-import { forceRetry } from "../../utils/forceRetry";
 import { transformPrismaSchemaHistories } from "./histories/transformPrismaSchemaHistories";
 import { IAutoBePrismaSchemaApplication } from "./structures/IAutoBePrismaSchemaApplication";
 
 export async function orchestratePrismaSchemas<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  components: AutoBePrisma.IComponent[],
+  componentList: AutoBePrisma.IComponent[],
 ): Promise<AutoBePrismaSchemasEvent[]> {
   const start: Date = new Date();
-  const total: number = components
+  const total: number = componentList
     .map((c) => c.tables.length)
     .reduce((x, y) => x + y, 0);
-  let completed: number = 0;
+  const completed: IPointer<number> = { value: 0 };
   return await Promise.all(
-    components.map(async (comp) => {
-      const targetComponent: AutoBePrisma.IComponent = comp;
-      const otherComponents: AutoBePrisma.IComponent[] = components.filter(
-        (y) => comp !== y,
-      );
-      const result: IAutoBePrismaSchemaApplication.IProps = await forceRetry(
-        () => process(ctx, targetComponent, otherComponents),
-      );
-      const event: AutoBePrismaSchemasEvent = {
-        type: "prismaSchemas",
-        created_at: start.toISOString(),
-        thinking: result.thinking,
-        draft: result.draft,
-        review: result.review,
-        final: result.final,
-        file: {
-          filename: comp.filename,
-          namespace: comp.namespace,
-          models: result.models,
-        },
-        completed: (completed += comp.tables.length),
+    componentList.map(async (component) => {
+      const otherTables: string[] = componentList
+        .filter((y) => component !== y)
+        .map((c) => c.tables)
+        .flat();
+      const event: AutoBePrismaSchemasEvent = await process(ctx, {
+        component,
+        otherTables,
+        start,
         total,
-        step: ctx.state().analyze?.step ?? 0,
-      };
+        completed,
+      });
       ctx.dispatch(event);
       return event;
     }),
@@ -55,119 +40,126 @@ export async function orchestratePrismaSchemas<Model extends ILlmSchema.Model>(
 
 async function process<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  targetComponent: AutoBePrisma.IComponent,
-  otherComponents: AutoBePrisma.IComponent[],
-): Promise<IAutoBePrismaSchemaApplication.IProps> {
+  props: {
+    component: AutoBePrisma.IComponent;
+    otherTables: string[];
+    start: Date;
+    total: number;
+    completed: IPointer<number>;
+  },
+): Promise<AutoBePrismaSchemasEvent> {
   const pointer: IPointer<IAutoBePrismaSchemaApplication.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: "prismaSchemas",
     histories: transformPrismaSchemaHistories(
-      ctx.state().analyze!.files,
-      targetComponent,
-      otherComponents,
+      ctx
+        .state()
+        .analyze?.files.map((file) => ({ [file.filename]: file.content }))
+        .reduce((acc, cur) => {
+          return Object.assign(acc, cur);
+        }, {}) ?? {},
+      props.component,
+      props.otherTables,
     ),
-    controllers: [
-      createApplication(ctx, {
-        targetComponent,
-        otherComponents,
-        build: (next) => {
-          pointer.value = next;
-        },
-      }),
-    ],
-  });
-  enforceToolCall(agentica);
-
-  await agentica.conversate("Make prisma schema file please").finally(() => {
-    const tokenUsage = agentica.getTokenUsage().aggregate;
-    ctx.usage().record(tokenUsage, ["prisma"]);
+    controller: createController(ctx, {
+      targetComponent: props.component,
+      otherTables: props.otherTables,
+      build: (next) => {
+        pointer.value = next;
+      },
+    }),
+    enforceFunctionCall: true,
+    message: "Make prisma schema file please",
   });
   if (pointer.value === null)
     throw new Error("Unreachable code: Prisma Schema not generated");
-  return pointer.value;
+  return {
+    type: "prismaSchemas",
+    created_at: props.start.toISOString(),
+    plan: pointer.value.plan,
+    models: pointer.value.models,
+    file: {
+      filename: props.component.filename,
+      namespace: props.component.namespace,
+      models: pointer.value.models,
+    },
+    tokenUsage,
+    completed: (props.completed.value += props.component.tables.length),
+    total: props.total,
+    step: ctx.state().analyze?.step ?? 0,
+  } satisfies AutoBePrismaSchemasEvent;
 }
 
-function createApplication<Model extends ILlmSchema.Model>(
+function createController<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   props: {
     targetComponent: AutoBePrisma.IComponent;
-    otherComponents: AutoBePrisma.IComponent[];
+    otherTables: string[];
     build: (next: IAutoBePrismaSchemaApplication.IProps) => void;
   },
 ): IAgenticaController.IClass<Model> {
   assertSchemaModel(ctx.model);
-  const application: ILlmApplication<Model> = collection[
-    ctx.model
-  ] as unknown as ILlmApplication<Model>;
-  // application.functions[0].validate = (
-  //   input: unknown,
-  // ): IValidation<IMakePrismaSchemaFileProps> => {
-  //   const result: IValidation<IMakePrismaSchemaFileProps> =
-  //     typia.validate<IMakePrismaSchemaFileProps>(input);
-  //   if (result.success === false) return result;
 
-  //   const everyModels: AutoBePrisma.IModel[] = result.data.models;
-  //   result.data.models = result.data.models.filter((m) =>
-  //     props.otherComponents.every((oc) => oc.tables.includes(m.name) === false),
-  //   );
-  //   const expected: string[] = props.targetComponent.tables;
-  //   const actual: string[] = result.data.models.map((m) => m.name);
-  //   const missed: string[] = expected.filter(
-  //     (x) => actual.includes(x) === false,
-  //   );
-  //   if (missed.length === 0) return result;
+  const validate = (
+    input: unknown,
+  ): IValidation<IAutoBePrismaSchemaApplication.IProps> => {
+    const result: IValidation<IAutoBePrismaSchemaApplication.IProps> =
+      typia.validate<IAutoBePrismaSchemaApplication.IProps>(input);
+    if (result.success === false) return result;
+
+    const actual: AutoBePrisma.IModel[] = result.data.models;
+    const expected: string[] = props.targetComponent.tables;
+    const missed: string[] = expected.filter(
+      (x) => actual.some((a) => a.name === x) === false,
+    );
+    if (missed.length === 0) return result;
 
-  //   ctx.dispatch({
-  //     type: "prismaInsufficient",
-  //     created_at: new Date().toISOString(),
-  //     component: props.targetComponent,
-  //     actual: everyModels,
-  //     missed,
-  //     tablesToCreate: result.data.tablesToCreate,
-  //     validationReview: result.data.validationReview,
-  //     confirmedTables: result.data.confirmedTables,
-  //   });
-  //   return {
-  //     success: false,
-  //     data: result.data,
-  //     errors: [
-  //       {
-  //         path: "$input.file.models",
-  //         value: result.data.models,
-  //         expected: `Array<AutoBePrisma.IModel>`,
-  //         description: [
-  //           "You missed some tables from the current domain's component.",
-  //           "",
-  //           "Look at the following details to fix the schemas. Never forget to",
-  //           "compose the `missed` tables at the next function calling.",
-  //           "",
-  //           "- filename: current domain's filename",
-  //           "- namespace: current domain's namespace",
-  //           "- expected: expected tables in the current domain",
-  //           "- actual: actual tables you made",
-  //           "- missed: tables you have missed, and you have to compose again",
-  //           "",
-  //           JSON.stringify({
-  //             filename: props.targetComponent.filename,
-  //             namespace: props.targetComponent.namespace,
-  //             expected,
-  //             actual,
-  //             missed,
-  //           }),
-  //         ].join("\n"),
-  //       },
-  //     ],
-  //   };
-  // };
+    ctx.dispatch({
+      type: "prismaInsufficient",
+      created_at: new Date().toISOString(),
+      component: props.targetComponent,
+      actual,
+      missed,
+    });
+    return {
+      success: false,
+      data: result.data,
+      errors: [
+        {
+          path: "$input.models",
+          value: result.data.models,
+          expected: `Array<AutoBePrisma.IModel>`,
+          description: [
+            "You missed some tables from the current domain's component.",
+            "",
+            "Look at the following details to fix the schemas. Never forget to",
+            "compose the `missed` tables at the next function calling.",
+            "",
+            "- filename: current domain's filename",
+            "- namespace: current domain's namespace",
+            "- expected: expected tables in the current domain",
+            "- actual: actual tables you made",
+            "- missed: tables you have missed, and you have to compose again",
+            "",
+            JSON.stringify({
+              filename: props.targetComponent.filename,
+              namespace: props.targetComponent.namespace,
+              expected,
+              actual,
+              missed,
+            }),
+          ].join("\n"),
+        },
+      ],
+    };
+  };
+  const application: ILlmApplication<Model> = collection[
+    ctx.model === "chatgpt" ? "chatgpt" : "claude"
+  ](
+    validate,
+  ) satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
   return {
     protocol: "class",
     name: "Prisma Generator",
@@ -180,19 +172,21 @@ function createApplication<Model extends ILlmSchema.Model>(
   };
 }
 
-const claude = typia.llm.application<
-  IAutoBePrismaSchemaApplication,
-  "claude",
-  { reference: true }
->();
 const collection = {
-  chatgpt: typia.llm.application<
-    IAutoBePrismaSchemaApplication,
-    "chatgpt",
-    { reference: true }
-  >(),
-  claude,
-  llama: claude,
-  deepseek: claude,
-  "3.1": claude,
+  chatgpt: (validate: Validator) =>
+    typia.llm.application<IAutoBePrismaSchemaApplication, "chatgpt">({
+      validate: {
+        makePrismaSchemaFile: validate,
+      },
+    }),
+  claude: (validate: Validator) =>
+    typia.llm.application<IAutoBePrismaSchemaApplication, "claude">({
+      validate: {
+        makePrismaSchemaFile: validate,
+      },
+    }),
 };
+
+type Validator = (
+  input: unknown,
+) => IValidation<IAutoBePrismaSchemaApplication.IProps>;

package/src/orchestrate/prisma/structures/IAutoBePrismaComponentApplication.ts

@@ -1,4 +1,5 @@
 import { AutoBePrisma } from "@autobe/interface";
+import { tags } from "typia";
 
 export interface IAutoBePrismaComponentApplication {
   /**
@@ -119,6 +120,6 @@ export namespace IAutoBePrismaComponentApplication {
      * - Filename numbering indicates dependency order for schema generation
      * - Namespace is used for documentation organization and domain grouping
      */
-    components: AutoBePrisma.IComponent[];
+    components: AutoBePrisma.IComponent[] & tags.MinItems<1>;
   }
 }

package/src/orchestrate/prisma/structures/IAutoBePrismaReviewApplication.ts

@@ -0,0 +1,108 @@
+import { AutoBePrisma } from "@autobe/interface";
+
+export interface IAutoBePrismaReviewApplication {
+  /**
+   * Reviews and validates Prisma schema modifications to ensure compliance with
+   * database design best practices and business requirements.
+   *
+   * Performs comprehensive validation of proposed schema changes including
+   * normalization compliance, relationship integrity, performance optimization,
+   * and business logic alignment. The review process ensures all modifications
+   * maintain data consistency and follow enterprise-level database standards.
+   */
+  reviewSchemaFile(props: IAutoBePrismaReviewApplication.IProps): void;
+}
+export namespace IAutoBePrismaReviewApplication {
+  export interface IProps {
+    /**
+     * Comprehensive review analysis of the proposed schema modifications.
+     *
+     * Contains the AI agent's detailed evaluation of the schema changes,
+     * including validation of normalization compliance, relationship integrity,
+     * index optimization, and business requirement alignment. The review
+     * identifies potential issues and confirms adherence to best practices.
+     *
+     * **Review Dimensions:**
+     *
+     * - **Normalization Validation**: Confirms 3NF compliance and proper data
+     *   structure
+     * - **Relationship Integrity**: Validates foreign key references and
+     *   cardinality
+     * - **Performance Optimization**: Reviews indexing strategy and query
+     *   patterns
+     * - **Business Logic Alignment**: Ensures schema supports all use cases
+     * - **Naming Conventions**: Verifies consistent naming patterns
+     * - **Data Type Consistency**: Confirms appropriate field types
+     * - **Temporal Field Handling**: Validates audit trail implementation
+     *
+     * **Example:**
+     *
+     *     "After reviewing the schema modifications:
+     *     1. All tables properly implement UUID primary keys
+     *     2. Foreign key relationships correctly reference existing models
+     *     3. Composite indexes optimize for common query patterns
+     *     4. Snapshot tables include proper temporal fields
+     *     5. Materialized views (mv_) contain appropriate denormalization
+     *     The schema follows all best practices and is ready for implementation."
+     */
+    review: string;
+
+    /**
+     * Strategic database design plan that guided the schema creation.
+     *
+     * Contains the original planning document that outlines the database
+     * architecture strategy, including table structures, relationships,
+     * normalization approach, and business requirement mapping. This plan
+     * serves as the blueprint for validating the implemented schema.
+     *
+     * **Planning Components:**
+     *
+     * - **Business Requirements**: Mapping of business needs to database
+     *   structures
+     * - **Table Design**: Entity definitions and attribute specifications
+     * - **Relationship Strategy**: Cardinality and referential integrity planning
+     * - **Normalization Approach**: Application of 1NF, 2NF, 3NF principles
+     * - **Performance Considerations**: Index strategy and query optimization
+     * - **Snapshot Architecture**: Temporal data handling and audit requirements
+     * - **Materialized Views**: Denormalization strategy for performance
+     *
+     * **Example:**
+     *
+     *     "Database Design Strategy:
+     *     Component: Sales Domain
+     *     Tables: shopping_sales, shopping_sale_snapshots, shopping_sale_units
+     *
+     *     Design Approach:
+     *     - Normalize product catalog to 3NF for data integrity
+     *     - Implement snapshot pattern for price history tracking
+     *     - Create composite indexes for product search queries
+     *     - Use materialized views for sales analytics dashboards"
+     */
+    plan: string;
+
+    /**
+     * Array of Prisma models that have been modified based on review feedback.
+     *
+     * Contains ONLY the models that required changes, not the entire schema.
+     * Each model represents a complete table definition with all fields,
+     * relationships, indexes, and documentation. These modifications will be
+     * applied to the models to produce the final implementation.
+     *
+     * **Model Requirements:**
+     *
+     * - **Complete Models**: Each entry must be a complete model definition
+     * - **Targeted Changes**: Only includes models that need modifications
+     * - **AST Compliance**: Follows AutoBePrisma.IModel interface structure
+     * - **Relationship Integrity**: All foreign keys reference valid models
+     * - **Index Optimization**: Strategic indexes without redundancy
+     * - **Documentation**: Comprehensive English descriptions
+     *
+     * **Notes:**
+     *
+     * - Models not included in this array remain unchanged from the models
+     * - The final schema merges these modifications with the original models
+     * - All modifications must resolve issues identified in the review
+     */
+    modifications: AutoBePrisma.IModel[];
+  }
+}