@autobe/agent 0.16.1 → 0.18.0

package/src/orchestrate/prisma/orchestratePrismaCorrect.ts

@@ -1,6 +1,7 @@
-import { IAgenticaController, MicroAgentica } from "@agentica/core";
+import { IAgenticaController } from "@agentica/core";
 import {
   AutoBePrisma,
+  AutoBePrismaCorrectEvent,
   IAutoBeCompiler,
   IAutoBePrismaValidation,
 } from "@autobe/interface";
@@ -10,8 +11,8 @@ import typia from "typia";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
-import { enforceToolCall } from "../../utils/enforceToolCall";
-import { transformPrismaCorrectHistories } from "./transformPrismaCorrectHistories";
+import { transformPrismaCorrectHistories } from "./histories/transformPrismaCorrectHistories";
+import { IAutoBePrismaCorrectApplication } from "./structures/IAutoBePrismaCorrectApplication";
 
 export function orchestratePrismaCorrect<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
@@ -26,10 +27,10 @@ export function orchestratePrismaCorrect<Model extends ILlmSchema.Model>(
       return true;
     });
   application.files = application.files.filter((f) => f.models.length !== 0);
-  return step(ctx, application, life);
+  return iterate(ctx, application, life);
 }
 
-async function step<Model extends ILlmSchema.Model>(
+async function iterate<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   application: AutoBePrisma.IApplication,
   life: number,
@@ -56,82 +57,114 @@ async function step<Model extends ILlmSchema.Model>(
     step: ctx.state().analyze?.step ?? 0,
     created_at: new Date().toISOString(),
   });
+  const next: IExecutionResult = await process(ctx, result);
+  return iterate(ctx, next.correction, life - 1);
+}
+
+async function process<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  failure: IAutoBePrismaValidation.IFailure,
+  capacity: number = 8,
+): Promise<IExecutionResult> {
+  const count: number = getTableCount(failure);
+  if (count <= capacity) return execute(ctx, failure);
 
-  const pointer: IPointer<IModifyPrismaSchemaFilesProps | null> = {
+  let correction: AutoBePrisma.IApplication = failure.data;
+  const volume: number = Math.ceil(count / capacity);
+  const plannings: string[] = [];
+  const models: Record<string, AutoBePrisma.IModel> = {};
+  let i: number = 0;
+
+  while (i++ < volume && failure.errors.length !== 0) {
+    const next: IExecutionResult = await execute(ctx, {
+      ...failure,
+      errors: (() => {
+        const unique: Set<string | null> = new Set();
+        const errors: IAutoBePrismaValidation.IError[] = [];
+        for (const err of failure.errors) {
+          unique.add(err.table ?? null);
+          if (unique.size > capacity) break;
+          else errors.push(err);
+        }
+        return errors;
+      })(),
+    });
+    plannings.push(next.planning);
+    for (const m of next.models) models[m.name] = m;
+
+    const compiler: IAutoBeCompiler = await ctx.compiler();
+    const result: IAutoBePrismaValidation = await compiler.prisma.validate(
+      next.correction,
+    );
+    correction = next.correction;
+    if (result.success === true) break;
+    else failure = result;
+  }
+  return {
+    planning: plannings.join("\n\n"),
+    models: Object.values(models),
+    correction,
+  };
+}
+
+async function execute<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  failure: IAutoBePrismaValidation.IFailure,
+): Promise<IExecutionResult> {
+  // PREPARE AGENTICA
+  const pointer: IPointer<IAutoBePrismaCorrectApplication.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: "prismaCorrect",
+    histories: transformPrismaCorrectHistories(failure),
+    controller: createController({
+      model: ctx.model,
+      build: (next) => {
+        pointer.value = next;
       },
-    },
-    histories: transformPrismaCorrectHistories(result),
-    controllers: [
-      createApplication({
-        model: ctx.model,
-        build: (next) => {
-          pointer.value = next;
-        },
-      }),
-    ],
-  });
-  enforceToolCall(agentica);
-
-  // REQUEST CORRECTION
-  await agentica
-    .conversate(
+    }),
+    enforceFunctionCall: true,
+    message:
       "Resolve the compilation errors in the provided Prisma schema files.",
-    )
-    .finally(() => {
-      const tokenUsage = agentica.getTokenUsage();
-      ctx.usage().record(tokenUsage, ["prisma"]);
-    });
-  if (pointer.value === null) {
-    console.error(
+  });
+  if (pointer.value === null)
+    throw new Error(
       "Unreachable error: PrismaCompilerAgent.pointer.value is null",
     );
-    return result; // unreachable
-  }
-
   const correction: AutoBePrisma.IApplication = {
-    files: application.files.map((file) => ({
+    files: failure.data.files.map((file) => ({
       filename: file.filename,
       namespace: file.namespace,
       models: file.models.map((model) => {
-        const newbie = pointer.value!.models.find((m) => m.name === model.name);
+        const newbie = pointer.value?.models.find((m) => m.name === model.name);
         return newbie ?? model;
       }),
     })),
   };
   ctx.dispatch({
     type: "prismaCorrect",
-    failure: result,
-    correction,
+    failure,
     planning: pointer.value.planning,
+    correction: correction,
+    tokenUsage,
     step: ctx.state().analyze?.step ?? 0,
     created_at: new Date().toISOString(),
-  });
-  return step(
-    ctx,
-    {
-      files: correction.files,
-    },
-    life - 1,
-  );
+  } satisfies AutoBePrismaCorrectEvent);
+  return {
+    ...pointer.value,
+    correction,
+  };
 }
 
-function createApplication<Model extends ILlmSchema.Model>(props: {
+function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
-  build: (next: IModifyPrismaSchemaFilesProps) => void;
+  build: (next: IAutoBePrismaCorrectApplication.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 Compiler",
@@ -140,164 +173,29 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
       correctPrismaSchemaFiles: (next) => {
         props.build(next);
       },
-    } satisfies IApplication,
+    } satisfies IAutoBePrismaCorrectApplication,
   };
 }
 
+const getTableCount = (failure: IAutoBePrismaValidation.IFailure): number => {
+  const unique: Set<string | null> = new Set(
+    failure.errors.map((error) => error.table ?? null),
+  );
+  return unique.size;
+};
+
 const claude = typia.llm.application<
-  IApplication,
-  "claude",
-  { reference: true }
+  IAutoBePrismaCorrectApplication,
+  "claude"
 >();
 const collection = {
-  chatgpt: typia.llm.application<
-    IApplication,
-    "chatgpt",
-    { reference: true }
-  >(),
+  chatgpt: typia.llm.application<IAutoBePrismaCorrectApplication, "chatgpt">(),
   claude,
   llama: claude,
   deepseek: claude,
   "3.1": claude,
 };
 
-interface IApplication {
-  /**
-   * 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: IModifyPrismaSchemaFilesProps): void;
-}
-
-interface IModifyPrismaSchemaFilesProps {
-  /**
-   * 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[];
+interface IExecutionResult extends IAutoBePrismaCorrectApplication.IProps {
+  correction: AutoBePrisma.IApplication;
 }

package/src/orchestrate/prisma/orchestratePrismaReview.ts

@@ -0,0 +1,118 @@
+import { IAgenticaController } from "@agentica/core";
+import { AutoBePrisma } from "@autobe/interface";
+import { AutoBePrismaReviewEvent } from "@autobe/interface/src/events/AutoBePrismaReviewEvent";
+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 { IProgress } from "../internal/IProgress";
+import { transformPrismaReviewHistories } from "./histories/transformPrismaReviewHistories";
+import { IAutoBePrismaReviewApplication } from "./structures/IAutoBePrismaReviewApplication";
+
+export async function orchestratePrismaReview<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  application: AutoBePrisma.IApplication,
+  schemas: Record<string, string>,
+  componentList: AutoBePrisma.IComponent[],
+): Promise<AutoBePrismaReviewEvent[]> {
+  const progress: IProgress = {
+    completed: 0,
+    total: componentList.length,
+  };
+  return await Promise.all(
+    componentList.map((component) =>
+      step(ctx, application, schemas, component, progress),
+    ),
+  );
+}
+
+async function step<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  application: AutoBePrisma.IApplication,
+  schemas: Record<string, string>,
+  component: AutoBePrisma.IComponent,
+  progress: IProgress,
+): Promise<AutoBePrismaReviewEvent> {
+  const start: Date = new Date();
+  const pointer: IPointer<IAutoBePrismaReviewApplication.IProps | null> = {
+    value: null,
+  };
+  const { tokenUsage } = await ctx.conversate({
+    source: "prismaReview",
+    histories: transformPrismaReviewHistories({
+      analysis:
+        ctx
+          .state()
+          .analyze?.files.map((file) => ({ [file.filename]: file.content }))
+          .reduce((acc, cur) => {
+            return Object.assign(acc, cur);
+          }, {}) ?? {},
+      application,
+      schemas,
+      component,
+    }),
+    controller: createController(ctx, {
+      build: (next) => {
+        pointer.value = next;
+      },
+    }),
+    enforceFunctionCall: true,
+    message: "Please review the Prisma schema file.",
+  });
+  if (pointer.value === null)
+    throw new Error("Failed to review the Prisma schema.");
+
+  const event: AutoBePrismaReviewEvent = {
+    type: "prismaReview",
+    created_at: start.toISOString(),
+    filename: component.filename,
+    review: pointer.value.review,
+    plan: pointer.value.plan,
+    modifications: pointer.value.modifications,
+    tokenUsage,
+    completed: ++progress.completed,
+    total: progress.total,
+    step: ctx.state().analyze?.step ?? 0,
+  };
+  ctx.dispatch(event);
+  return event;
+}
+
+function createController<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  props: {
+    build: (next: IAutoBePrismaReviewApplication.IProps) => void;
+  },
+): IAgenticaController.IClass<Model> {
+  assertSchemaModel(ctx.model);
+
+  const application: ILlmApplication<Model> = collection[
+    ctx.model
+  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
+
+  return {
+    protocol: "class",
+    name: "Prisma Schema Review",
+    application,
+    execute: {
+      reviewSchemaFile: (next) => {
+        props.build(next);
+      },
+    } satisfies IAutoBePrismaReviewApplication,
+  };
+}
+
+const claude = typia.llm.application<
+  IAutoBePrismaReviewApplication,
+  "claude"
+>();
+
+const collection = {
+  chatgpt: typia.llm.application<IAutoBePrismaReviewApplication, "chatgpt">(),
+  claude,
+  llama: claude,
+  deepseek: claude,
+  "3.1": claude,
+};