@autobe/agent 0.10.6 → 0.11.1

package/src/orchestrate/prisma/orchestratePrismaSchemas.ts

@@ -0,0 +1,265 @@
+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";
+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";
+
+export async function orchestratePrismaSchemas<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  components: AutoBePrisma.IComponent[],
+): Promise<AutoBePrismaSchemasEvent[]> {
+  const start: Date = new Date();
+  const total: number = components
+    .map((c) => c.tables.length)
+    .reduce((x, y) => x + y, 0);
+  let completed: number = 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),
+        total,
+        step: ctx.state().analyze?.step ?? 0,
+      };
+      ctx.dispatch(event);
+      return event;
+    }),
+  );
+}
+
+async function process<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  targetComponent: AutoBePrisma.IComponent,
+  otherComponents: AutoBePrisma.IComponent[],
+): Promise<IMakePrismaSchemaFileProps> {
+  const pointer: IPointer<IMakePrismaSchemaFileProps | null> = {
+    value: null,
+  };
+  const agentica: MicroAgentica<Model> = new MicroAgentica({
+    model: ctx.model,
+    vendor: ctx.vendor,
+    config: {
+      ...(ctx.config ?? {}),
+      executor: {
+        describe: null,
+      },
+    },
+    histories: transformPrismaSchemaHistories(
+      ctx.state().analyze!.files,
+      targetComponent,
+      otherComponents,
+    ),
+    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"]);
+  });
+  if (pointer.value === null)
+    throw new Error("Unreachable code: Prisma Schema not generated");
+  return pointer.value;
+}
+
+function createApplication<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  props: {
+    targetComponent: AutoBePrisma.IComponent;
+    otherComponents: AutoBePrisma.IComponent[];
+    build: (next: IMakePrismaSchemaFileProps) => 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;
+
+  //   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"),
+  //       },
+  //     ],
+  //   };
+  // };
+  return {
+    protocol: "class",
+    name: "Prisma Generator",
+    application,
+    execute: {
+      makePrismaSchemaFile: (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,
+};
+
+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[];
+}

package/src/orchestrate/prisma/transformPrismaSchemaHistories.ts

@@ -1,16 +1,13 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
-import { AutoBeAnalyzeHistory } from "@autobe/interface";
+import { AutoBePrisma } from "@autobe/interface";
 import { v4 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
 
 export const transformPrismaSchemaHistories = (
-  analyze: AutoBeAnalyzeHistory,
-  component: {
-    filename: string;
-    tables: string[];
-    entireTables: string[];
-  },
+  requirementAnalysisReport: Record<string, string>,
+  targetComponent: AutoBePrisma.IComponent,
+  otherComponents: AutoBePrisma.IComponent[],
 ): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
 > => {
@@ -21,44 +18,36 @@ export const transformPrismaSchemaHistories = (
       type: "systemMessage",
       text: AutoBeSystemPromptConstant.PRISMA_SCHEMA,
     },
-    // {
-    //   id: v4(),
-    //   created_at: new Date().toISOString(),
-    //   type: "systemMessage",
-    //   text: [
-    //     "Before making prisma schema files,",
-    //     "learn about the prisma schema language",
-    //     "from the best practices and examples",
-    //     "",
-    //     AutoBeSystemPromptConstant.PRISMA_EXAMPLE,
-    //   ].join("\n"),
-    // },
     {
       id: v4(),
       created_at: new Date().toISOString(),
-      type: "systemMessage",
+      type: "assistantMessage",
       text: [
-        "Here is the requirement analysis report.",
-        "",
-        "Call the provided tool function to generate Prisma DB schema",
-        "referencing below requirement analysis report.",
+        "Here is the input data for generating Prisma DB schema.",
         "",
-        "## User Request",
-        analyze.reason,
-        "",
-        `## Requirement Analysis Report`,
+        "```",
+        JSON.stringify({
+          requirementAnalysisReport,
+          otherComponents,
+          targetComponent,
+        }),
+        "```",
+      ].join("\n"),
+    },
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: [
+        "You've already taken a mistake that creating models from the other components.",
+        "Note that, you have to make models from the target component only. Never make",
+        "models from the other components. The other components' models are already made.",
         "",
         "```json",
-        JSON.stringify(analyze.files),
+        JSON.stringify({
+          targetComponent,
+        }),
         "```",
-        "",
-        "## Context",
-        "",
-        `  - Target filename: ${component.filename}`,
-        `  - Tables what you have to make:`,
-        ...component.tables.map((table) => `    - ${table}`),
-        `  - Entire tables you can reference:`,
-        ...component.entireTables.map((table) => `    - ${table}`),
       ].join("\n"),
     },
   ];

package/src/orchestrate/realize/RealizePipe.ts

@@ -0,0 +1,39 @@
+import { FAILED } from "./structures/IAutoBeRealizeFailedSymbol";
+
+export function pipe<A, B>(
+  a: A,
+  ab: (a: A) => Promise<B | FAILED>,
+): Promise<B | FAILED>;
+
+export function pipe<A, B, C>(
+  a: A,
+  ab: (a: A) => Promise<B | FAILED>,
+  bc: (b: B) => Promise<C | FAILED>,
+): Promise<C | FAILED>;
+
+export function pipe<A, B, C, D>(
+  a: A,
+  ab: (a: A) => Promise<B | FAILED>,
+  bc: (b: B) => Promise<C | FAILED>,
+  cd: (c: C) => Promise<D | FAILED>,
+): Promise<D | FAILED>;
+
+export function pipe<A, B, C, D, E>(
+  a: A,
+  ab: (a: A) => Promise<B | FAILED>,
+  bc: (b: B) => Promise<C | FAILED>,
+  cd: (c: C) => Promise<D | FAILED>,
+  de: (d: D) => Promise<E | FAILED>,
+): Promise<E | FAILED>;
+
+export function pipe(
+  a: any,
+  ...fns: Array<(arg: any) => Promise<any>>
+): Promise<any> {
+  return fns.reduce((prev, fn) => {
+    return prev.then((result) => {
+      if (result === FAILED) return FAILED;
+      return fn(result);
+    });
+  }, Promise.resolve(a));
+}

package/src/orchestrate/realize/orchestrateRealize.ts

@@ -1,6 +1,5 @@
 import {
   AutoBeAssistantMessageHistory,
-  AutoBeOpenApi,
   AutoBeRealizeHistory,
 } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
@@ -8,9 +7,7 @@ import { v4 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
-import { orchestrateRealizeCoder } from "./orchestrateRealizeCoder";
-import { orchestrateRealizePlanner } from "./orchestrateRealizePlanner";
-import { IAutoBeRealizeCoderApplication } from "./structures/IAutoBeRealizeCoderApplication";
+import { writeCodeUntilCompilePassed } from "./writeCodeUntilCompilePassed";
 
 export const orchestrateRealize =
   <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) =>
@@ -20,55 +17,10 @@ export const orchestrateRealize =
     props;
     const ops = ctx.state().interface?.document.operations;
     if (!ops) {
-      throw new Error();
-    }
-
-    const files: Record<string, string> = {
-      ...ctx.state().interface?.files,
-      ...ctx.state().test?.files.reduce(
-        (acc, file) => {
-          acc[file.location] = file.content;
-          return acc;
-        },
-        {} as Record<string, string>,
-      ),
-    };
-
-    const codes: IAutoBeRealizeCoderApplication.IPipeOutput[] =
-      await Promise.all(
-        ops.map(async (op) => ({
-          operation: op,
-          result: await pipe(
-            op,
-            (op) => orchestrateRealizePlanner(ctx, op),
-            (p) => orchestrateRealizeCoder(ctx, op, p, files),
-          ),
-        })),
-      );
-
-    const successes: Array<{
-      operation: AutoBeOpenApi.IOperation;
-      result: IAutoBeRealizeCoderApplication.RealizeCoderOutput;
-    }> = [];
-    const failures: Array<{
-      operation: AutoBeOpenApi.IOperation;
-      result: FAILED;
-    }> = [];
-
-    for (const code of codes) {
-      if (code.result === FAILED) {
-        failures.push({
-          operation: code.operation,
-          result: code.result,
-        });
-      } else {
-        successes.push({
-          operation: code.operation,
-          result: code.result,
-        });
-      }
+      throw new Error("Can't do realize agent because operations are nothing.");
     }
 
+    await writeCodeUntilCompilePassed(ctx, ops, 3);
     const now = new Date().toISOString();
     ctx.dispatch({
       type: "assistantMessage",
@@ -87,43 +39,3 @@ export const orchestrateRealize =
       step: ctx.state().test?.step ?? 0,
     };
   };
-
-export const FAILED = Symbol("FAILED");
-export type FAILED = typeof FAILED;
-
-export function pipe<A, B>(
-  a: A,
-  ab: (a: A) => Promise<B | FAILED>,
-): Promise<B | FAILED>;
-
-export function pipe<A, B, C>(
-  a: A,
-  ab: (a: A) => Promise<B | FAILED>,
-  bc: (b: B) => Promise<C | FAILED>,
-): Promise<C | FAILED>;
-
-export function pipe<A, B, C, D>(
-  a: A,
-  ab: (a: A) => Promise<B | FAILED>,
-  bc: (b: B) => Promise<C | FAILED>,
-  cd: (c: C) => Promise<D | FAILED>,
-): Promise<D | FAILED>;
-
-export function pipe<A, B, C, D>(
-  a: A,
-  ab: (a: A) => Promise<B | FAILED>,
-  bc: (b: B) => Promise<C | FAILED>,
-  cd: (c: C) => Promise<D | FAILED>,
-): Promise<D | FAILED>;
-
-export function pipe(
-  a: any,
-  ...fns: Array<(arg: any) => Promise<any>>
-): Promise<any> {
-  return fns.reduce((prev, fn) => {
-    return prev.then((result) => {
-      if (result === FAILED) return FAILED;
-      return fn(result);
-    });
-  }, Promise.resolve(a));
-}

package/src/orchestrate/realize/orchestrateRealizeCoder.ts

@@ -1,5 +1,9 @@
 import { IAgenticaController, MicroAgentica } from "@agentica/core";
-import { AutoBeOpenApi } from "@autobe/interface";
+import {
+  AutoBeOpenApi,
+  IAutoBeCompiler,
+  IAutoBeTypeScriptCompileResult,
+} from "@autobe/interface";
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
 import { IPointer } from "tstl";
 import typia from "typia";
@@ -9,9 +13,9 @@ import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { enforceToolCall } from "../../utils/enforceToolCall";
 import { getTestScenarioArtifacts } from "../test/compile/getTestScenarioArtifacts";
 import { IAutoBeTestScenarioArtifacts } from "../test/structures/IAutoBeTestScenarioArtifacts";
-import { FAILED } from "./orchestrateRealize";
 import { RealizePlannerOutput } from "./orchestrateRealizePlanner";
 import { IAutoBeRealizeCoderApplication } from "./structures/IAutoBeRealizeCoderApplication";
+import { FAILED } from "./structures/IAutoBeRealizeFailedSymbol";
 import { transformRealizeCoderHistories } from "./transformRealizeCoderHistories";
 
 /**
@@ -36,8 +40,16 @@ export const orchestrateRealizeCoder = async <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   operation: AutoBeOpenApi.IOperation,
   props: RealizePlannerOutput,
-  files: Record<string, string>,
-): Promise<IAutoBeRealizeCoderApplication.RealizeCoderOutput | FAILED> => {
+  previous: string | null,
+  total: IAutoBeTypeScriptCompileResult.IDiagnostic[],
+  diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[],
+): Promise<
+  | Pick<
+      IAutoBeRealizeCoderApplication.RealizeCoderOutput,
+      "filename" | "implementationCode"
+    >
+  | FAILED
+> => {
   const artifacts: IAutoBeTestScenarioArtifacts =
     await getTestScenarioArtifacts(ctx, {
       endpoint: {
@@ -57,7 +69,7 @@ export const orchestrateRealizeCoder = async <Model extends ILlmSchema.Model>(
   const controller = createApplication({
     model: ctx.model,
     build: (props) => {
-      pointer.value = props.result;
+      pointer.value = props.output;
     },
   });
 
@@ -71,7 +83,14 @@ export const orchestrateRealizeCoder = async <Model extends ILlmSchema.Model>(
         describe: null,
       },
     },
-    histories: transformRealizeCoderHistories(ctx.state(), props, artifacts),
+    histories: transformRealizeCoderHistories(
+      ctx.state(),
+      props,
+      artifacts,
+      previous,
+      total,
+      diagnostics,
+    ),
   });
   enforceToolCall(agent);
 
@@ -83,29 +102,45 @@ export const orchestrateRealizeCoder = async <Model extends ILlmSchema.Model>(
     return FAILED;
   }
 
-  pointer.value.implementationCode = await ctx.compiler.typescript.beautify(
+  pointer.value.implementationCode = await replaceImportStatements(ctx)(
     pointer.value.implementationCode,
   );
-  pointer.value.implementationCode = pointer.value.implementationCode
-    .replaceAll('import { MyGlobal } from "../MyGlobal";', "")
-    .replaceAll('import typia, { tags } from "typia";', "")
-    .replaceAll('import { Prisma } from "@prisma/client";', "")
-    .replaceAll('import { jwtDecode } from "./jwtDecode"', "");
-  pointer.value.implementationCode = [
-    'import { MyGlobal } from "../MyGlobal";',
-    'import typia, { tags } from "typia";',
-    'import { Prisma } from "@prisma/client";',
-    'import { jwtDecode } from "./jwtDecode"',
-    "",
-    pointer.value.implementationCode,
-  ].join("\n");
-
-  files[`src/providers/${props.functionName}.ts`] =
-    pointer.value.implementationCode;
 
-  return { ...pointer.value, functionName: props.functionName };
+  return {
+    ...pointer.value,
+    filename: `src/providers/${props.functionName}.ts`,
+  };
 };
 
+function replaceImportStatements<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+) {
+  return async function (code: string) {
+    const compiler: IAutoBeCompiler = await ctx.compiler();
+    code = await compiler.typescript.beautify(code);
+    code = code
+      .replaceAll('import { MyGlobal } from "../MyGlobal";', "")
+      .replaceAll('import typia, { tags } from "typia";', "")
+      .replaceAll('import { tags } from "typia";', "")
+      .replaceAll('import { tags, typia } from "typia";', "")
+      .replaceAll('import typia from "typia";', "")
+      .replaceAll('import { Prisma } from "@prisma/client";', "")
+      .replaceAll('import { jwtDecode } from "./jwtDecode"', "")
+      .replaceAll('import { v4 } from "uuid"', "");
+    code = [
+      'import { MyGlobal } from "../MyGlobal";',
+      'import typia, { tags } from "typia";',
+      'import { Prisma } from "@prisma/client";',
+      'import { jwtDecode } from "./jwtDecode";',
+      'import { v4 } from "uuid";',
+      "",
+      code,
+    ].join("\n");
+
+    return code;
+  };
+}
+
 function createApplication<Model extends ILlmSchema.Model>(props: {
   model: Model;
   build: (next: IAutoBeRealizeCoderApplication.IProps) => void;
@@ -121,7 +156,7 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
     name: "Write code",
     application,
     execute: {
-      programing: (next) => {
+      programming: (next) => {
         props.build(next);
       },
     } satisfies IAutoBeRealizeCoderApplication,