@autobe/agent 0.16.1 → 0.18.0

package/src/orchestrate/prisma/orchestratePrismaSchemas.ts

@@ -1,47 +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 "./transformPrismaSchemaHistories";
+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: IMakePrismaSchemaFileProps = await forceRetry(() =>
-        process(ctx, targetComponent, otherComponents),
-      );
-      const event: AutoBePrismaSchemasEvent = {
-        type: "prismaSchemas",
-        created_at: start.toISOString(),
-        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;
     }),
@@ -50,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<IMakePrismaSchemaFileProps> {
-  const pointer: IPointer<IMakePrismaSchemaFileProps | null> = {
+  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();
-    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[];
-    build: (next: IMakePrismaSchemaFileProps) => void;
+    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",
@@ -171,95 +168,25 @@ function createApplication<Model extends ILlmSchema.Model>(
       makePrismaSchemaFile: (next) => {
         props.build(next);
       },
-    } satisfies IApplication,
+    } satisfies IAutoBePrismaSchemaApplication,
   };
 }
 
-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,
+  chatgpt: (validate: Validator) =>
+    typia.llm.application<IAutoBePrismaSchemaApplication, "chatgpt">({
+      validate: {
+        makePrismaSchemaFile: validate,
+      },
+    }),
+  claude: (validate: Validator) =>
+    typia.llm.application<IAutoBePrismaSchemaApplication, "claude">({
+      validate: {
+        makePrismaSchemaFile: validate,
+      },
+    }),
 };
 
-interface IApplication {
-  /**
-   * Generates comprehensive Prisma schema files based on detailed requirements
-   * analysis.
-   *
-   * Creates multiple organized schema files following enterprise patterns
-   * including proper domain separation, relationship modeling, snapshot
-   * patterns, inheritance, materialized views, and comprehensive documentation.
-   * The generated schemas implement best practices for scalability,
-   * maintainability, and data integrity.
-   *
-   * @param props Properties containing the file
-   */
-  makePrismaSchemaFile(props: IMakePrismaSchemaFileProps): void;
-}
-
-interface IMakePrismaSchemaFileProps {
-  /**
-   * STEP 1: First enumeration of tables that must be created
-   *
-   * List all table names that need to be created based on the
-   * `targetComponent.tables`. This should be an exact copy of the
-   * `targetComponent.tables` array.
-   *
-   * Example: ["shopping_goods", "shopping_goods_options"]
-   */
-  tablesToCreate: string[];
-
-  /**
-   * STEP 2: Validation review of the first enumeration
-   *
-   * Compare `tablesToCreate` against `targetComponent.tables` and
-   * `otherComponents[].tables`. Write a review statement that validates:
-   *
-   * - All tables from `targetComponent.tables` are included
-   * - No tables from `otherComponents[].tables` are included
-   * - Additional tables (if any) are for M:N junction relationships or
-   *   domain-specific needs
-   * - No forbidden tables from other domains are included
-   *
-   * Example: "VALIDATION PASSED: All required tables from
-   * `targetComponent.tables` included: shopping_goods, shopping_goods_options.
-   * FORBIDDEN CHECK: No tables from `otherComponents` included
-   * (shopping_customers, shopping_sellers are correctly excluded). Additional
-   * tables: none needed for this domain."
-   */
-  validationReview: string;
-
-  /**
-   * STEP 3: Second enumeration of tables to create
-   *
-   * After validation, re-list the tables that will be created. This should be
-   * identical to `tablesToCreate` if validation passed. This serves as the
-   * final confirmed list before model creation.
-   *
-   * Example: ["shopping_goods", "shopping_goods_options"]
-   */
-  confirmedTables: string[];
-
-  /**
-   * STEP 4: Array of Prisma models (database tables) within the domain
-   *
-   * Create exactly one model for each table in `confirmedTables`. Each model
-   * represents a business entity or concept within the namespace. Models can
-   * reference each other through foreign key relationships.
-   *
-   * The `models` array length must equal `confirmedTables.length`. Each
-   * `model.name` must match an entry in `confirmedTables`.
-   */
-  models: AutoBePrisma.IModel[];
-}
+type Validator = (
+  input: unknown,
+) => IValidation<IAutoBePrismaSchemaApplication.IProps>;

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

@@ -0,0 +1,125 @@
+import { AutoBePrisma } from "@autobe/interface";
+import { tags } from "typia";
+
+export interface IAutoBePrismaComponentApplication {
+  /**
+   * Organizes database tables into domain-based components for Prisma schema
+   * generation.
+   *
+   * Takes business requirements and groups related tables into logical domains,
+   * with each component becoming a separate .prisma file.
+   */
+  extractComponents(props: IAutoBePrismaComponentApplication.IProps): void;
+}
+export namespace IAutoBePrismaComponentApplication {
+  export interface IProps {
+    /**
+     * Initial thoughts on namespace classification criteria.
+     *
+     * Contains the AI agent's initial analysis and reasoning about how to
+     * organize tables into different business domains/namespaces.
+     *
+     * **Example:**
+     *
+     *     "Based on the business requirements, I identify several key domains:
+     *     - User-related entities should be grouped under 'Actors' namespace
+     *     - Product and sales information under 'Sales' namespace
+     *     - System configuration under 'Systematic' namespace"
+     */
+    thinking: string;
+
+    /**
+     * Review and refinement of the namespace classification.
+     *
+     * Contains the AI agent's review process, considering relationships between
+     * tables and potential improvements to the initial classification.
+     *
+     * **Example:**
+     *
+     *     "Upon review, I noticed that 'shopping_channel_categories' has strong
+     *     relationships with both channels and sales. However, since it primarily
+     *     defines the channel structure, it should remain in 'Systematic' namespace."
+     */
+    review: string;
+
+    /**
+     * Final decision on namespace classification.
+     *
+     * Contains the AI agent's final reasoning and rationale for the chosen
+     * namespace organization, explaining why this structure best serves the
+     * business requirements.
+     *
+     * **Example:**
+     *
+     *     "Final decision: Organize tables into 3 main namespaces:
+     *     1. Systematic - for channel and system configuration
+     *     2. Actors - for all user types (customers, citizens, administrators)
+     *     3. Sales - for product sales and related transactional data
+     *     This structure provides clear separation of concerns and follows DDD principles."
+     */
+    decision: string;
+
+    /**
+     * Array of domain components that group related database tables.
+     *
+     * Each component represents a business domain and becomes one Prisma schema
+     * file. Common domains include: Actors (users), Sales (products), Orders,
+     * Carts, etc.
+     *
+     * **Example:**
+     *
+     * ```typescript
+     * {
+     *   "components": [
+     *     {
+     *       "filename": "schema-02-systematic.prisma",
+     *       "namespace": "Systematic",
+     *       "thinking": "These tables all relate to system configuration and channel management. They form the foundation of the platform.",
+     *       "review": "Considering the relationships, shopping_channel_categories connects channels and sales, but it fundamentally defines channel structure.",
+     *       "rationale": "Grouping all system configuration tables together provides a clear foundation layer that other domains can reference.",
+     *       "tables": [
+     *         "shopping_channels",
+     *         "shopping_sections",
+     *         "shopping_channel_categories"
+     *       ]
+     *     },
+     *     {
+     *       "filename": "schema-03-actors.prisma",
+     *       "namespace": "Actors",
+     *       "thinking": "All user-related entities should be grouped together as they share authentication and identity patterns.",
+     *       "review": "While customers interact with sales, the customer entity itself is about identity, not transactions.",
+     *       "rationale": "This component groups all actor-related tables to maintain separation between identity management and business transactions.",
+     *       "tables": [
+     *         "shopping_customers",
+     *         "shopping_citizens",
+     *         "shopping_administrators"
+     *       ]
+     *     },
+     *     {
+     *       "filename": "schema-04-sales.prisma",
+     *       "namespace": "Sales",
+     *       "thinking": "Product catalog and sales-related tables belong together as they form the core commerce functionality.",
+     *       "review": "Sales snapshots are integral to the sales domain for tracking product history and price changes.",
+     *       "rationale": "Consolidating all sales-related tables enables coherent management of the entire product lifecycle.",
+     *       "tables": [
+     *         "shopping_sales",
+     *         "shopping_sale_snapshots",
+     *         "shopping_sale_units",
+     *         "shopping_sale_unit_options"
+     *       ]
+     *     }
+     *   ]
+     * }
+     * ```
+     *
+     * **Notes:**
+     *
+     * - Table names must follow snake_case convention with domain prefix (e.g.,
+     *   `shopping_customers`)
+     * - Each component becomes one `.prisma` file containing related models
+     * - Filename numbering indicates dependency order for schema generation
+     * - Namespace is used for documentation organization and domain grouping
+     */
+    components: AutoBePrisma.IComponent[] & tags.MinItems<1>;
+  }
+}

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

@@ -0,0 +1,144 @@
+import { AutoBePrisma } from "@autobe/interface";
+
+export interface IAutoBePrismaCorrectApplication {
+  /**
+   * Fixes validation errors in specific AutoBePrisma models while preserving
+   * ALL existing business logic and model descriptions.
+   *
+   * ## Core Rules
+   *
+   * 1. Fix ONLY validation errors in provided models - never remove business
+   *    descriptions
+   * 2. Apply minimal changes to error models only - preserve original design
+   *    intent
+   * 3. Return ONLY corrected models - unchanged models remain in original schema
+   * 4. Maintain referential integrity with unchanged models
+   *
+   * ## Targeted Scope
+   *
+   * - Process ONLY models with validation errors from IError[] array
+   * - Exclude models without errors from processing and output
+   * - Minimize context usage by returning corrected models only
+   * - Preserve unchanged models in their original state
+   *
+   * ## Fix Strategy
+   *
+   * - Resolve validation errors within specific models only
+   * - Fix field duplications, invalid references, and type mismatches
+   * - Update cross-model references without modifying target models
+   * - Ensure naming conventions and index rules compliance in corrected models
+   */
+  correctPrismaSchemaFiles(props: IAutoBePrismaCorrectApplication.IProps): void;
+}
+export namespace IAutoBePrismaCorrectApplication {
+  export interface IProps {
+    /**
+     * Detailed execution plan for fixing `AutoBePrisma` validation errors in
+     * specific models.
+     *
+     * 🎯 Purpose: Enable systematic reasoning and step-by-step error resolution
+     * approach for targeted model validation issues
+     *
+     * 📋 Required Planning Content:
+     *
+     * 1. **Error Scope Analysis**
+     *
+     *    - List all validation errors from IAutoBePrismaValidation.IError[] array
+     *    - Extract unique table names from errors to identify affected models
+     *    - Categorize errors by type (field duplications, references, types,
+     *         indexes)
+     *    - Identify which models need correction vs. which remain unchanged
+     * 2. **Targeted Fix Strategy**
+     *
+     *    - Focus ONLY on models mentioned in validation errors
+     *    - Outline minimal changes needed for each affected model
+     *    - Plan cross-model reference updates (if any) without modifying non-error
+     *         models
+     *    - Ensure unchanged models maintain valid references to corrected models
+     * 3. **Model-Specific Fix Plan**
+     *
+     *    - Model-by-model modification plan for ONLY affected models
+     *    - Exact field additions, renames, or type corrections required
+     *    - Reference updates within corrected models only
+     *    - Index corrections limited to affected models
+     * 4. **Minimal Scope Validation**
+     *
+     *    - Confirm which models will be included in output (error models only)
+     *    - List models that will remain unchanged in original schema
+     *    - Identify cross-model dependencies without including unchanged models
+     *    - Preserve all business logic within corrected models
+     * 5. **Targeted Impact Assessment**
+     *
+     *    - Potential effects of fixes on unchanged models (reference validation)
+     *    - Verification points for corrected models only
+     *    - Ensure no new validation errors in targeted models
+     *    - Confirm minimal output scope compliance
+     *
+     * 💡 Example Planning Structure:
+     *
+     *     ## Error Scope
+     *     - Target Models: shopping_customers, shopping_orders (2 models only)
+     *     - Unchanged Models: All others remain in original schema
+     *
+     *     ## Targeted Fixes
+     *     - shopping_customers: Remove duplicate 'email' field
+     *     - shopping_orders: Update targetModel reference to 'shopping_customers'
+     *
+     *     ## Output Scope
+     *     - Return: Only shopping_customers and shopping_orders models
+     *     - Preserve: All other models unchanged in original schema
+     *
+     *     ## Cross-Model Impact
+     *     - Verify: shopping_orders still references shopping_customers correctly
+     *     - No changes needed in other models referencing these
+     */
+    planning: string;
+
+    /**
+     * ONLY the specific models that contain validation errors and need
+     * correction.
+     *
+     * 📥 Input Structure:
+     *
+     * - Contains ONLY models mentioned in IAutoBePrismaValidation.IError[] array
+     * - Each model has specific validation errors that need targeted correction
+     * - Models not mentioned in errors are excluded from this input
+     * - Represents minimal scope for error correction
+     *
+     * 🔍 Expected Validation Issues (Model-Specific):
+     *
+     * - Duplicate field/relation names within these specific models
+     * - Invalid foreign key references from these models to other models
+     * - Single foreign key fields in index arrays within these models
+     * - Invalid naming conventions within these specific models
+     * - Type validation errors in fields of these models
+     *
+     * 📝 Model Content Analysis (Targeted Scope):
+     *
+     * - Complete field definitions for each error model only
+     * - Relationships from these models (may reference unchanged models)
+     * - Indexes within these models that need correction
+     * - Business descriptions specific to these models
+     * - Cross-model references that need validation (read-only for targets)
+     *
+     * ⚠️ Processing Notes (Focused Approach):
+     *
+     * - Input contains ONLY models with validation errors
+     * - May reference other models not included in this input
+     * - Cross-model references must be validated but target models won't be
+     *   modified
+     * - Output should return corrected versions of ONLY these input models
+     * - All business logic and descriptions within these models must be preserved
+     * - Corrections must not break references from unchanged models
+     *
+     * 🎯 Correction Scope:
+     *
+     * - Fix validation errors within these specific models
+     * - Update internal model structure (fields, relations, indexes)
+     * - Correct references to external models (without modifying targets)
+     * - Maintain compatibility with unchanged models in the full schema
+     * - Return corrected versions of ONLY these models
+     */
+    models: AutoBePrisma.IModel[];
+  }
+}