@autobe/agent 0.3.24 → 0.4.0

package/src/orchestrate/prisma/orchestratePrismaCorrect.ts

@@ -0,0 +1,258 @@
+import { IAgenticaController, MicroAgentica } from "@agentica/core";
+import { AutoBePrisma, IAutoBePrismaValidation } from "@autobe/interface";
+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 { transformPrismaCorrectHistories } from "./transformPrismaCorrectHistories";
+
+export function orchestratePrismaCorrect<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  application: AutoBePrisma.IApplication,
+  retry: number = 8,
+): Promise<IAutoBePrismaValidation> {
+  return step(ctx, application, retry);
+}
+
+async function step<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  application: AutoBePrisma.IApplication,
+  life: number,
+): Promise<IAutoBePrismaValidation> {
+  const result: IAutoBePrismaValidation =
+    await ctx.compiler.prisma.validate(application);
+  if (result.success) return result; // SUCCESS
+
+  // VALIDATION FAILED
+  const schemas: Record<string, string> =
+    await ctx.compiler.prisma.write(application);
+  ctx.dispatch({
+    type: "prismaValidate",
+    result,
+    schemas,
+    compiled: await ctx.compiler.prisma.compile({
+      files: schemas,
+    }),
+    step: ctx.state().analyze?.step ?? 0,
+    created_at: new Date().toISOString(),
+  });
+
+  const pointer: IPointer<IModifyPrismaSchemaFilesProps | null> = {
+    value: null,
+  };
+  const agentica: MicroAgentica<Model> = new MicroAgentica({
+    model: ctx.model,
+    vendor: ctx.vendor,
+    config: {
+      ...(ctx.config ?? {}),
+    },
+    histories: transformPrismaCorrectHistories(result),
+    tokenUsage: ctx.usage(),
+    controllers: [
+      createApplication({
+        model: ctx.model,
+        build: (next) => {
+          pointer.value = next;
+        },
+      }),
+    ],
+  });
+  agentica.on("request", (event) => {
+    if (event.body.tools) {
+      event.body.tool_choice = "required";
+    }
+  });
+
+  // REQUEST CORRECTION
+  await agentica.conversate(
+    "Resolve the compilation errors in the provided Prisma schema files.",
+  );
+  if (pointer.value === null) {
+    console.error(
+      "Unreachable error: PrismaCompilerAgent.pointer.value is null",
+    );
+    return result; // unreachable
+  }
+
+  ctx.dispatch({
+    type: "prismaCorrect",
+    failure: result,
+    correction: {
+      files: pointer.value.files,
+    },
+    planning: pointer.value.planning,
+    step: ctx.state().analyze?.step ?? 0,
+    created_at: new Date().toISOString(),
+  });
+  return step(
+    ctx,
+    {
+      files: pointer.value.files,
+    },
+    life - 1,
+  );
+}
+
+function createApplication<Model extends ILlmSchema.Model>(props: {
+  model: Model;
+  build: (next: IModifyPrismaSchemaFilesProps) => void;
+}): IAgenticaController.IClass<Model> {
+  assertSchemaModel(props.model);
+  const application: ILlmApplication<Model> = collection[
+    props.model
+  ] as unknown as ILlmApplication<Model>;
+  return {
+    protocol: "class",
+    name: "Prisma Compiler",
+    application,
+    execute: {
+      correctPrismaSchemaFiles: (next) => {
+        props.build(next);
+      },
+    } satisfies IApplication,
+  };
+}
+
+const claude = typia.llm.application<
+  IApplication,
+  "claude",
+  { reference: true }
+>();
+const collection = {
+  chatgpt: typia.llm.application<
+    IApplication,
+    "chatgpt",
+    { reference: true }
+  >(),
+  claude,
+  llama: claude,
+  deepseek: claude,
+  "3.1": claude,
+  "3.0": typia.llm.application<IApplication, "3.0">(),
+};
+
+interface IApplication {
+  /**
+   * Fixes validation errors in AutoBePrisma.IApplication structure while
+   * preserving ALL existing business logic and model descriptions.
+   *
+   * ## Core Rules
+   *
+   * 1. Fix ONLY validation errors - never remove business descriptions
+   * 2. Apply minimal changes - preserve original design intent
+   * 3. Return COMPLETE corrected structure - no data loss allowed
+   * 4. Maintain referential integrity across all models
+   *
+   * ## Preservation Requirements
+   *
+   * - Keep ALL model and field descriptions
+   * - Keep business logic and architectural patterns
+   * - Maintain relationship semantics and cardinality
+   * - Remove descriptions only when removing duplicate elements
+   *
+   * ## Fix Strategy
+   *
+   * - Resolve structural validation errors without changing business intent
+   * - Remove duplicate fields/relations while preserving most appropriate ones
+   * - Fix invalid references and type mismatches
+   * - Ensure naming conventions and index rules compliance
+   */
+  correctPrismaSchemaFiles(props: IModifyPrismaSchemaFilesProps): void;
+}
+
+interface IModifyPrismaSchemaFilesProps {
+  /**
+   * Detailed execution plan for fixing AutoBePrisma validation errors.
+   *
+   * 🎯 Purpose: Enable systematic reasoning and step-by-step error resolution
+   * approach for structured schema validation issues
+   *
+   * 📋 Required Planning Content:
+   *
+   * 1. **Error Analysis Summary**
+   *
+   *    - List all validation errors from IAutoBePrismaValidation.IError[] array
+   *    - Categorize errors by type (duplications, references, types, indexes)
+   *    - Identify root causes and error interdependencies
+   * 2. **Fix Strategy Overview**
+   *
+   *    - Prioritize fixes based on dependencies (fix duplications first)
+   *    - Outline minimal changes needed for each validation error
+   *    - Identify potential impact on other models/relationships
+   * 3. **Step-by-Step Fix Plan**
+   *
+   *    - Model-by-model modification plan with specific changes
+   *    - Exact field additions, removals, or renames required
+   *    - Reference updates needed for renamed elements
+   *    - Index corrections to comply with validation rules
+   * 4. **Preservation Checklist**
+   *
+   *    - Confirm which descriptions and business logic must be preserved
+   *    - List relationships and constraints to maintain unchanged
+   *    - Identify cross-model dependencies that must remain intact
+   * 5. **Risk Assessment**
+   *
+   *    - Potential side effects of each planned fix
+   *    - Validation points to check after applying corrections
+   *    - Ensure no new validation errors are introduced
+   *
+   * 💡 Example Planning Structure:
+   *
+   *     ## Error Analysis
+   *     - Error 1: Duplicate field 'name' in shopping_customers model
+   *     - Error 2: Invalid targetModel 'shopping_customer' should be 'shopping_customers'
+   *
+   *     ## Fix Strategy
+   *     1. Remove duplicate 'name' field (keep the more detailed one)
+   *     2. Update foreign key references to use correct plural model name
+   *
+   *     ## Detailed Steps
+   *     1. shopping_customers model: Remove second 'name' field from plainFields
+   *     2. shopping_orders model: Update targetModel from 'shopping_customer' to 'shopping_customers'
+   *
+   *     ## Preservation Notes
+   *     - Keep business descriptions for remaining 'name' field
+   *     - Maintain all relationship semantics
+   *     - Preserve all indexes and constraints
+   */
+  planning: string;
+
+  /**
+   * Original AutoBePrisma.IApplication structure that contains validation
+   * errors and needs correction.
+   *
+   * 📥 Input Structure:
+   *
+   * - Complete IApplication with files array containing validation errors
+   * - Each file contains models with potential structural issues
+   * - Errors may include duplications, invalid references, or constraint
+   *   violations
+   *
+   * 🔍 Expected Validation Issues:
+   *
+   * - Duplicate model names across files
+   * - Duplicate field/relation names within models
+   * - Invalid foreign key references to non-existent models
+   * - Single foreign key fields in index arrays
+   * - Non-plural model names or invalid naming conventions
+   *
+   * 📝 Application Content Analysis:
+   *
+   * - All models with their complete field definitions
+   * - All relationships with targetModel and targetfield configurations
+   * - All indexes (unique, plain, GIN) with field references
+   * - All business descriptions and requirement mappings
+   * - Cross-file model references and dependencies
+   *
+   * ⚠️ Processing Notes:
+   *
+   * - Structure may contain validation errors that prevent code generation
+   * - Some models might reference non-existent targets
+   * - Field names might violate naming conventions
+   * - Index configurations might include forbidden single foreign keys
+   * - Business logic and descriptions must be preserved during fixes
+   */
+  files: AutoBePrisma.IFile[];
+}

package/src/orchestrate/prisma/orchestratePrismaSchema.ts

@@ -1,4 +1,5 @@
 import { IAgenticaController, MicroAgentica } from "@agentica/core";
+import { AutoBePrisma } from "@autobe/interface";
 import { AutoBePrismaSchemasEvent } from "@autobe/interface/src/events/AutoBePrismaSchemasEvent";
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
 import { IPointer } from "tstl";
@@ -19,10 +20,9 @@ export async function orchestratePrismaSchemas<Model extends ILlmSchema.Model>(
 
   const total: number = components.reduce((acc, c) => acc + c.tables.length, 0);
   let i: number = 0;
-
   return await Promise.all(
     components.map(async (c) => {
-      const result: IMakePrismaSchemaFilesProps = await process(ctx, {
+      const result: IMakePrismaSchemaFileProps = await process(ctx, {
         filename: c.filename,
         tables: c.tables,
         entireTables,
@@ -30,8 +30,7 @@ export async function orchestratePrismaSchemas<Model extends ILlmSchema.Model>(
       const event: AutoBePrismaSchemasEvent = {
         type: "prismaSchemas",
         created_at: start.toISOString(),
-        filename: c.filename,
-        content: result.content,
+        file: result.file,
         completed: (i += c.tables.length),
         total,
         step: ctx.state().analyze?.step ?? 0,
@@ -49,8 +48,8 @@ async function process<Model extends ILlmSchema.Model>(
     tables: string[];
     entireTables: string[];
   },
-): Promise<IMakePrismaSchemaFilesProps> {
-  const pointer: IPointer<IMakePrismaSchemaFilesProps | null> = {
+): Promise<IMakePrismaSchemaFileProps> {
+  const pointer: IPointer<IMakePrismaSchemaFileProps | null> = {
     value: null,
   };
   const agentica: MicroAgentica<Model> = new MicroAgentica({
@@ -66,6 +65,7 @@ async function process<Model extends ILlmSchema.Model>(
         model: ctx.model,
         build: (next) => {
           pointer.value = next;
+          pointer.value.file.filename = component.filename;
         },
       }),
     ],
@@ -75,42 +75,15 @@ async function process<Model extends ILlmSchema.Model>(
       event.body.tool_choice = "required";
     }
   });
-
-  await agentica.conversate(
-    [
-      "Please generate Prisma schema files based on the previous requirement analysis report.",
-      "",
-      "**Context:**",
-      `- Target filename: \`${component.filename}\``,
-      `- Tables to implement in this file: \`${component.tables.join("`, `")}\``,
-      `- All available tables in the system: \`${component.entireTables.join("`, `")}\``,
-      "",
-      "**Instructions:**",
-      "1. Create comprehensive Prisma schema content for the specified tables",
-      "2. Reference the previous requirement analysis to understand business logic and data structures",
-      "3. Establish appropriate relationships between tables using the entireTables list as reference",
-      "4. Include proper field types, constraints, indexes, and documentation",
-      "5. Follow enterprise-level schema design patterns and best practices",
-      "6. Ensure cross-table relationships are accurately modeled based on business requirements",
-      "",
-      "**Key Requirements:**",
-      "- Implement only the tables specified for this file",
-      "- Create foreign key relationships to tables from entireTables when business logic requires it",
-      "- Add comprehensive field documentation and model descriptions",
-      "- Include appropriate indexes for performance optimization",
-      "- Follow consistent naming conventions and data types",
-    ].join("\n"),
-  );
-
+  await agentica.conversate("Make prisma schema file please");
   if (pointer.value === null)
     throw new Error("Unreachable code: Prisma Schema not generated");
-
   return pointer.value;
 }
 
 function createApplication<Model extends ILlmSchema.Model>(props: {
   model: Model;
-  build: (next: IMakePrismaSchemaFilesProps) => void;
+  build: (next: IMakePrismaSchemaFileProps) => void;
 }): IAgenticaController.IClass<Model> {
   assertSchemaModel(props.model);
   const application: ILlmApplication<Model> = collection[
@@ -121,7 +94,7 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
     name: "Prisma Generator",
     application,
     execute: {
-      makePrismaSchemaFiles: (next) => {
+      makePrismaSchemaFile: (next) => {
         props.build(next);
       },
     } satisfies IApplication,
@@ -157,27 +130,17 @@ interface IApplication {
    * The generated schemas implement best practices for scalability,
    * maintainability, and data integrity.
    *
-   * @param props Properties containing the complete set of Prisma schema files
+   * @param props Properties containing the file
    */
-  makePrismaSchemaFiles(props: IMakePrismaSchemaFilesProps): void;
+  makePrismaSchemaFile(props: IMakePrismaSchemaFileProps): void;
 }
 
-interface IMakePrismaSchemaFilesProps {
+interface IMakePrismaSchemaFileProps {
   /**
-   * Complete Prisma schema content as a single concatenated string.
-   *
-   * Contains all schema files organized by domain/functionality with clear file
-   * separators. Each file section includes models, relationships, indexes, and
-   * comprehensive documentation following enterprise patterns.
+   * Complete definition of a single Prisma schema file.
    *
-   * Content should be organized following enterprise patterns:
-   *
-   * - Main.prisma: Configuration, datasource, and generators
-   * - Schema-XX-domain.prisma: Domain-specific entity definitions
-   * - Proper cross-file relationships and dependencies
+   * Represents one business domain containing related models, organized for
+   * modular schema management and following domain-driven design principles.
    */
-  content: string;
-
-  /** Summary description of the application requirements and business context. */
-  description: string;
+  file: AutoBePrisma.IFile;
 }

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

@@ -1,36 +1,36 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
-import { IAutoBePrismaCompilerResult } from "@autobe/interface";
+import { IAutoBePrismaValidation } from "@autobe/interface";
 
 import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
 
-export const transformPrismaCompilerHistories = (
-  files: Record<string, string>,
-  result: IAutoBePrismaCompilerResult.IFailure,
+export const transformPrismaCorrectHistories = (
+  result: IAutoBePrismaValidation.IFailure,
 ): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
 > => {
   return [
     {
       type: "systemMessage",
-      text: AutoBeSystemPromptConstant.PRISMA_COMPILER,
+      text: AutoBeSystemPromptConstant.PRISMA_CORRECT,
     },
     {
       type: "assistantMessage",
       text: [
-        "Below are the current schema files that failed compilation:",
+        "Here is the Prisma application data what you made:",
         "",
         "```json",
-        JSON.stringify(files),
+        JSON.stringify(result.data),
         "```",
       ].join("\n"),
     },
     {
       type: "assistantMessage",
       text: [
-        `Here is the compiler error message. Please fix the schema files`,
-        `referencing the error message.`,
+        "Below are the list of errors what you have to fix:",
         "",
-        result.reason,
+        "```json",
+        JSON.stringify(result.errors),
+        "```",
       ].join("\n"),
     },
     {

package/lib/orchestrate/prisma/orchestratePrismaCompiler.d.ts

@@ -1,4 +0,0 @@
-import { IAutoBePrismaCompilerResult } from "@autobe/interface";
-import { ILlmSchema } from "@samchon/openapi";
-import { AutoBeContext } from "../../context/AutoBeContext";
-export declare function orchestratePrismaCompiler<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, files: Record<string, string>, retry?: number): Promise<IAutoBePrismaCompilerResult>;