@autobe/agent 0.24.1 → 0.25.0

package/src/orchestrate/interface/orchestrateInterfaceOperations.ts

@@ -26,14 +26,16 @@ export async function orchestrateInterfaceOperations<
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
-  endpoints: AutoBeOpenApi.IEndpoint[],
-  capacity: number = AutoBeConfigConstant.INTERFACE_CAPACITY,
+  props: {
+    instruction: string;
+    endpoints: AutoBeOpenApi.IEndpoint[];
+    capacity?: number;
+  },
 ): Promise<AutoBeOpenApi.IOperation[]> {
   const matrix: AutoBeOpenApi.IEndpoint[][] = divideArray({
-    array: endpoints,
-    capacity,
+    array: props.endpoints,
+    capacity: props.capacity ?? AutoBeConfigConstant.INTERFACE_CAPACITY,
   });
-
   const progress: AutoBeProgressEventBase = {
     total: matrix.flat().length,
     completed: 0,
@@ -45,13 +47,13 @@ export async function orchestrateInterfaceOperations<
   return (
     await executeCachedBatch(
       matrix.map((it) => async (promptCacheKey) => {
-        const row: AutoBeOpenApi.IOperation[] = await divideAndConquer(
-          ctx,
-          it,
+        const row: AutoBeOpenApi.IOperation[] = await divideAndConquer(ctx, {
+          endpoints: it,
           progress,
           reviewProgress,
           promptCacheKey,
-        );
+          instruction: props.instruction,
+        });
         return row;
       }),
     )
@@ -60,13 +62,16 @@ export async function orchestrateInterfaceOperations<
 
 async function divideAndConquer<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  endpoints: AutoBeOpenApi.IEndpoint[],
-  operationsProgress: AutoBeProgressEventBase,
-  operationsReviewProgress: AutoBeProgressEventBase,
-  promptCacheKey: string,
+  props: {
+    endpoints: AutoBeOpenApi.IEndpoint[];
+    progress: AutoBeProgressEventBase;
+    reviewProgress: AutoBeProgressEventBase;
+    promptCacheKey: string;
+    instruction: string;
+  },
 ): Promise<AutoBeOpenApi.IOperation[]> {
   const remained: HashSet<AutoBeOpenApi.IEndpoint> = new HashSet(
-    endpoints,
+    props.endpoints,
     OpenApiEndpointComparator.hashCode,
     OpenApiEndpointComparator.equals,
   );
@@ -76,9 +81,15 @@ async function divideAndConquer<Model extends ILlmSchema.Model>(
       OpenApiEndpointComparator.equals,
     );
   for (let i: number = 0; i < ctx.retry; ++i) {
-    if (remained.empty() === true || unique.size() >= endpoints.length) break;
+    if (remained.empty() === true || unique.size() >= props.endpoints.length)
+      break;
     const operations: AutoBeOpenApi.IOperation[] = remained.size()
-      ? await process(ctx, remained, operationsProgress, promptCacheKey)
+      ? await process(ctx, {
+          endpoints: remained,
+          progress: props.progress,
+          promptCacheKey: props.promptCacheKey,
+          instruction: props.instruction,
+        })
       : [];
 
     for (const item of operations) {
@@ -90,7 +101,7 @@ async function divideAndConquer<Model extends ILlmSchema.Model>(
     await orchestrateInterfaceOperationsReview(
       ctx,
       unique.toJSON().map((it) => it.second),
-      operationsReviewProgress,
+      props.reviewProgress,
     );
   for (const item of newbie) unique.set(item, item);
   return unique.toJSON().map((it) => it.second);
@@ -98,9 +109,12 @@ async function divideAndConquer<Model extends ILlmSchema.Model>(
 
 async function process<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  endpoints: HashSet<AutoBeOpenApi.IEndpoint>,
-  progress: AutoBeProgressEventBase,
-  promptCacheKey: string,
+  props: {
+    endpoints: HashSet<AutoBeOpenApi.IEndpoint>;
+    progress: AutoBeProgressEventBase;
+    promptCacheKey: string;
+    instruction: string;
+  },
 ): Promise<AutoBeOpenApi.IOperation[]> {
   const prefix: string = NamingConvention.camel(ctx.state().analyze!.prefix);
   const pointer: IPointer<AutoBeOpenApi.IOperation[] | null> = {
@@ -108,10 +122,11 @@ async function process<Model extends ILlmSchema.Model>(
   };
   const { tokenUsage } = await ctx.conversate({
     source: "interfaceOperations",
-    histories: transformInterfaceOperationHistories(
-      ctx.state(),
-      endpoints.toJSON(),
-    ),
+    histories: transformInterfaceOperationHistories({
+      state: ctx.state(),
+      endpoints: props.endpoints.toJSON(),
+      instruction: props.instruction,
+    }),
     controller: createController({
       model: ctx.model,
       roles: ctx.state().analyze?.roles.map((it) => it.name) ?? [],
@@ -143,10 +158,10 @@ async function process<Model extends ILlmSchema.Model>(
           }));
         });
         pointer.value.push(...matrix.flat());
-        progress.completed += matrix.flat().length;
-        progress.total += operations
+        props.progress.completed += matrix.flat().length;
+        props.progress.total += operations
           .map((op) =>
-            endpoints.has({ path: op.path, method: op.method })
+            props.endpoints.has({ path: op.path, method: op.method })
               ? op.authorizationRoles.length === 0
                 ? 0
                 : op.authorizationRoles.length - 1
@@ -156,7 +171,7 @@ async function process<Model extends ILlmSchema.Model>(
       },
     }),
     enforceFunctionCall: true,
-    promptCacheKey,
+    promptCacheKey: props.promptCacheKey,
     message: "Make API operations",
   });
   if (pointer.value === null) throw new Error("Failed to create operations."); // never be happened
@@ -166,7 +181,7 @@ async function process<Model extends ILlmSchema.Model>(
     id: v7(),
     operations: pointer.value,
     tokenUsage,
-    ...progress,
+    ...props.progress,
     step: ctx.state().analyze?.step ?? 0,
     created_at: new Date().toISOString(),
   } satisfies AutoBeInterfaceOperationsEvent);

package/src/orchestrate/interface/orchestrateInterfaceSchemas.ts

@@ -27,15 +27,18 @@ export async function orchestrateInterfaceSchemas<
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
-  operations: AutoBeOpenApi.IOperation[],
-  capacity: number = AutoBeConfigConstant.INTERFACE_CAPACITY,
+  props: {
+    operations: AutoBeOpenApi.IOperation[];
+    instruction: string;
+    capacity?: number;
+  },
 ): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
   // fix operation type names
-  JsonSchemaNamingConvention.operations(operations);
+  JsonSchemaNamingConvention.operations(props.operations);
 
   // gather type names
   const typeNames: Set<string> = new Set();
-  for (const op of operations) {
+  for (const op of props.operations) {
     if (op.requestBody !== null) typeNames.add(op.requestBody.typeName);
     if (op.responseBody !== null) typeNames.add(op.responseBody.typeName);
   }
@@ -45,7 +48,7 @@ export async function orchestrateInterfaceSchemas<
   // divide and conquer
   const matrix: string[][] = divideArray({
     array: Array.from(typeNames),
-    capacity,
+    capacity: props.capacity ?? AutoBeConfigConstant.INTERFACE_CAPACITY,
   });
   const progress: AutoBeProgressEventBase = {
     total: typeNames.size,
@@ -57,39 +60,48 @@ export async function orchestrateInterfaceSchemas<
   for (const y of await executeCachedBatch(
     matrix.map((it) => async (promptCacheKey) => {
       const row: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
-        await divideAndConquer(ctx, operations, it, progress, promptCacheKey);
+        await divideAndConquer(ctx, {
+          instruction: props.instruction,
+          operations: props.operations,
+          typeNames: it,
+          progress,
+          promptCacheKey,
+        });
       return row;
     }),
   )) {
-    JsonSchemaNamingConvention.schemas(operations, x, y);
+    JsonSchemaNamingConvention.schemas(props.operations, x, y);
     Object.assign(x, y);
   }
   Object.assign(x, presets);
-  JsonSchemaNamingConvention.schemas(operations, x);
+  JsonSchemaNamingConvention.schemas(props.operations, x);
   JsonSchemaFactory.authorize(x);
   return x;
 }
 
 async function divideAndConquer<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  operations: AutoBeOpenApi.IOperation[],
-  typeNames: string[],
-  progress: AutoBeProgressEventBase,
-  promptCacheKey: string,
+  props: {
+    operations: AutoBeOpenApi.IOperation[];
+    typeNames: string[];
+    progress: AutoBeProgressEventBase;
+    promptCacheKey: string;
+    instruction: string;
+  },
 ): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
-  const remained: Set<string> = new Set(typeNames);
+  const remained: Set<string> = new Set(props.typeNames);
   const schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> = {};
   for (let i: number = 0; i < ctx.retry; ++i) {
     if (remained.size === 0) break;
     const newbie: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
-      await process(
-        ctx,
-        operations,
-        schemas,
+      await process(ctx, {
+        instruction: props.instruction,
+        operations: props.operations,
+        promptCacheKey: props.promptCacheKey,
+        progress: props.progress,
+        oldbie: schemas,
         remained,
-        progress,
-        promptCacheKey,
-      );
+      });
     for (const key of Object.keys(newbie)) {
       schemas[key] = newbie[key];
       remained.delete(key);
@@ -100,13 +112,16 @@ async function divideAndConquer<Model extends ILlmSchema.Model>(
 
 async function process<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  operations: AutoBeOpenApi.IOperation[],
-  oldbie: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>,
-  remained: Set<string>,
-  progress: AutoBeProgressEventBase,
-  promptCacheKey: string,
+  props: {
+    operations: AutoBeOpenApi.IOperation[];
+    oldbie: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
+    remained: Set<string>;
+    progress: AutoBeProgressEventBase;
+    promptCacheKey: string;
+    instruction: string;
+  },
 ): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
-  const already: string[] = Object.keys(oldbie);
+  const already: string[] = Object.keys(props.oldbie);
   const pointer: IPointer<Record<
     string,
     AutoBeOpenApi.IJsonSchemaDescriptive
@@ -115,7 +130,11 @@ async function process<Model extends ILlmSchema.Model>(
   };
   const { tokenUsage } = await ctx.conversate({
     source: "interfaceSchemas",
-    histories: transformInterfaceSchemaHistories(ctx.state(), operations),
+    histories: transformInterfaceSchemaHistories({
+      state: ctx.state(),
+      operations: props.operations,
+      instruction: props.instruction,
+    }),
     controller: createController({
       model: ctx.model,
       build: async (next) => {
@@ -125,7 +144,7 @@ async function process<Model extends ILlmSchema.Model>(
       pointer,
     }),
     enforceFunctionCall: true,
-    promptCacheKey,
+    promptCacheKey: props.promptCacheKey,
     message: StringUtil.trim`
       Make type components please.
 
@@ -134,7 +153,7 @@ async function process<Model extends ILlmSchema.Model>(
       types are required during making the components, please make them
       too.
 
-      ${Array.from(remained)
+      ${Array.from(props.remained)
         .map((k) => `      - \`${k}\``)
         .join("\n")}${
         already.length !== 0
@@ -161,9 +180,9 @@ async function process<Model extends ILlmSchema.Model>(
     id: v7(),
     schemas,
     tokenUsage,
-    completed: (progress.completed += Object.keys(schemas).length),
-    total: (progress.total += Object.keys(schemas).filter(
-      (k) => remained.has(k) === false,
+    completed: (props.progress.completed += Object.keys(schemas).length),
+    total: (props.progress.total += Object.keys(schemas).filter(
+      (k) => props.remained.has(k) === false,
     ).length),
     step: ctx.state().prisma?.step ?? 0,
     created_at: new Date().toISOString(),

package/src/orchestrate/interface/utils/JsonSchemaValidator.ts

@@ -25,22 +25,82 @@ export namespace JsonSchemaValidator {
     path: string;
     key: string;
   }): void => {
-    const variable: boolean = props.key.split(".").every(Escaper.variable);
-    if (variable === false)
+    const elements: string[] = props.key.split(".");
+    if (elements.every(Escaper.variable) === false)
       props.errors.push({
         path: `${props.path}[${JSON.stringify(props.key)}]`,
         expected: "Valid variable name",
         value: props.key,
         description: StringUtil.trim`
-            JSON schema type name must be a valid variable name.
+          JSON schema type name must be a valid variable name.
 
-            Even though JSON schema type name allows dot(.) character, but
-            each segment separated by dot(.) must be a valid variable name.
+          Even though JSON schema type name allows dot(.) character, but
+          each segment separated by dot(.) must be a valid variable name.
 
-            Current key name ${JSON.stringify(props.key)} is not valid. Change
-            it to a valid variable name at the next time.
-          `,
+          Current key name ${JSON.stringify(props.key)} is not valid. Change
+          it to a valid variable name at the next time.
+        `,
       });
+    if (props.key === "IPageIRequest")
+      props.errors.push({
+        path: `${props.path}[${JSON.stringify(props.key)}]`,
+        expected: `"IPageIRequest" is a mistake. Use "IPage.IRequest" instead.`,
+        value: props.key,
+        description: StringUtil.trim`
+          You've taken a mistake that defines "IPageIRequest" as a type name.
+          However, as you've intended to define a pagination request type, 
+          the correct type name is "IPage.IRequest" instead of "IPageIRequest".
+
+          Change it to "IPage.IRequest" at the next time.
+        `,
+      });
+    else if (
+      props.key.startsWith("IPage") &&
+      props.key.startsWith("IPageI") === false
+    ) {
+      const expected: string = `IPage${props.key
+        .substring(5)
+        .split(".")
+        .map((s) => (s.startsWith("I") ? s : `I${s}`))
+        .join(".")}`;
+      props.errors.push({
+        path: `${props.path}[${JSON.stringify(props.key)}]`,
+        expected: `Interface name starting with 'I' even after 'IPage': ${JSON.stringify(expected)}`,
+        value: props.key,
+        description: StringUtil.trim`
+          JSON schema type name must be an interface name starting with 'I'.
+          Even though JSON schema type name allows dot(.) character, but
+          each segment separated by dot(.) must be an interface name starting
+          with 'I'.
+
+          Even in the case of pagination response, after 'IPage' prefix,
+          the remaining part must be an interface name starting with 'I'.
+          
+          Current key name ${JSON.stringify(props.key)} is not valid. Change
+          it to a valid interface name to be  ${JSON.stringify(expected)},
+          or change it to another valid interface name at the next time.
+        `,
+      });
+    } else if (elements.some((s) => s.startsWith("I") === false) === true) {
+      const expected: string = elements
+        .map((s) => (s.startsWith("I") ? s : `I${s}`))
+        .join(".");
+      props.errors.push({
+        path: `${props.path}[${JSON.stringify(props.key)}]`,
+        expected: `Interface name starting with 'I': ${JSON.stringify(expected)}`,
+        value: props.key,
+        description: StringUtil.trim`
+          JSON schema type name must be an interface name starting with 'I'.
+          Even though JSON schema type name allows dot(.) character, but
+          each segment separated by dot(.) must be an interface name starting
+          with 'I'.
+
+          Current key name ${JSON.stringify(props.key)} is not valid. Change
+          it to a valid interface name to be ${JSON.stringify(expected)}, 
+          or change it to another valid interface name at the next time.
+        `,
+      });
+    }
   };
 
   const authorization = (props: IProps): void => {

package/src/orchestrate/interface/utils/OperationValidator.ts

@@ -48,12 +48,13 @@ export namespace OperationValidator {
           path: `${props.path}[${i}].requestBody.typeName`,
           key: op.requestBody.typeName,
         });
-      if (op.responseBody !== null)
+      if (op.responseBody !== null) {
         JsonSchemaValidator.validateKey({
           errors: props.errors,
           path: `${props.path}[${i}].responseBody.typeName`,
           key: op.responseBody.typeName,
         });
+      }
     });
 
     // validate duplicated endpoints

package/src/orchestrate/prisma/histories/transformPrismaComponentsHistories.ts

@@ -8,14 +8,17 @@ import { AutoBeState } from "../../../context/AutoBeState";
 
 export const transformPrismaComponentsHistories = (
   state: AutoBeState,
-  prefix: string | null = null,
+  props: {
+    prefix: string | null;
+    instruction: string;
+  },
 ): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
 > => {
   if (state.analyze === null)
     // unreachable
     throw new Error("Analyze state is not set.");
-  if (prefix) prefix = NamingConvention.snake(prefix);
+  if (props.prefix) props.prefix = NamingConvention.snake(props.prefix);
   return [
     {
       id: v7(),
@@ -28,20 +31,20 @@ export const transformPrismaComponentsHistories = (
       created_at: new Date().toISOString(),
       type: "assistantMessage",
       text: StringUtil.trim`
+        ## Requirement Analysis Report
+
         Here is the requirement analysis report.
         
         Call the provided tool function to generate Prisma DB schema
         referencing below requirement analysis report.
         
-        ## Requirement Analysis Report
-        
         \`\`\`json
         ${JSON.stringify(state.analyze.files)}
         \`\`\`
         
         ## Prefix
         
-        - Prefix provided by the user: ${prefix}
+        - Prefix provided by the user: ${props.prefix}
         
         The user wants all database schema (table) names to start with the prefix provided below.
         
@@ -74,11 +77,22 @@ export const transformPrismaComponentsHistories = (
                 Create separate tables for each role:
                 
                 ${state.analyze.roles
-                  .map((role) => `- ${prefix}_${role.name.toLowerCase()}`)
+                  .map((role) => `- ${props.prefix}_${role.name.toLowerCase()}`)
                   .join("\n")}
               `
             : ""
         }
+
+        ## Database Design Instructions
+
+        The following database-specific instructions were extracted by AI from
+        the user's utterances. These focus ONLY on database schema design aspects
+        such as table structure, relationships, constraints, and indexing strategies.
+
+        Reference these instructions when designing namespace components and 
+        DB table names.
+
+        ${props.instruction}
       `,
     },
   ];

package/src/orchestrate/prisma/histories/transformPrismaSchemaHistories.ts

@@ -5,11 +5,12 @@ import { v7 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
 
-export const transformPrismaSchemaHistories = (
-  requirementAnalysisReport: Record<string, string>,
-  targetComponent: AutoBePrisma.IComponent,
-  otherTables: string[],
-): Array<
+export const transformPrismaSchemaHistories = (props: {
+  analysis: Record<string, string>;
+  targetComponent: AutoBePrisma.IComponent;
+  otherTables: string[];
+  instruction: string;
+}): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
 > => {
   return [
@@ -27,7 +28,7 @@ export const transformPrismaSchemaHistories = (
         Here is the requirement analysis report:
 
         \`\`\`json
-        ${JSON.stringify(requirementAnalysisReport)}
+        ${JSON.stringify(props.analysis)}
         \`\`\`
       `,
     },
@@ -36,12 +37,26 @@ export const transformPrismaSchemaHistories = (
       created_at: new Date().toISOString(),
       type: "assistantMessage",
       text: StringUtil.trim`
+        ## Database Design Instructions
+
+        The following database-specific instructions were extracted by AI from
+        the user's utterances. These focus ONLY on database schema design aspects
+        such as table structure, relationships, constraints, and indexing strategies.
+
+        Reference these instructions when designing the DB schema for this specific
+        component. If the instruction is not related to the current domain or
+        component, you may ignore it.
+
+        ${props.instruction}
+
+        ## Target Component
+        
         Here is the input data for generating Prisma DB schema.
         
         \`\`\`json
         ${JSON.stringify({
-          targetComponent,
-          otherTables,
+          targetComponent: props.targetComponent,
+          otherTables: props.otherTables,
         })}
         \`\`\`
       `,
@@ -58,7 +73,7 @@ export const transformPrismaSchemaHistories = (
         
         \`\`\`json
         ${JSON.stringify({
-          targetComponent,
+          targetComponent: props.targetComponent,
         })}
         \`\`\`
       `,

package/src/orchestrate/prisma/orchestratePrisma.ts

@@ -39,18 +39,22 @@ export const orchestratePrisma = async <Model extends ILlmSchema.Model>(
     type: "prismaStart",
     id: v7(),
     created_at: start.toISOString(),
-    reason: props.reason,
+    reason: props.instruction,
     step: ctx.state().analyze?.step ?? 0,
   });
 
   // COMPONENTS
   const componentEvent: AutoBePrismaComponentsEvent =
-    await orchestratePrismaComponents(ctx);
+    await orchestratePrismaComponents(ctx, props.instruction);
   ctx.dispatch(componentEvent);
 
   // CONSTRUCT AST DATA
   const schemaEvents: AutoBePrismaSchemasEvent[] =
-    await orchestratePrismaSchemas(ctx, componentEvent.components);
+    await orchestratePrismaSchemas(
+      ctx,
+      props.instruction,
+      componentEvent.components,
+    );
   const application: AutoBePrisma.IApplication = {
     files: schemaEvents.map((e) => e.file),
   };

package/src/orchestrate/prisma/orchestratePrismaComponent.ts

@@ -14,6 +14,7 @@ export async function orchestratePrismaComponents<
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
+  instruction: string,
   message: string = "Design database from the given requirement analysis documents.",
 ): Promise<AutoBePrismaComponentsEvent> {
   const start: Date = new Date();
@@ -23,7 +24,10 @@ export async function orchestratePrismaComponents<
   const prefix: string | null = ctx.state().analyze?.prefix ?? null;
   const { tokenUsage } = await ctx.conversate({
     source: "prismaComponents",
-    histories: transformPrismaComponentsHistories(ctx.state(), prefix),
+    histories: transformPrismaComponentsHistories(ctx.state(), {
+      prefix,
+      instruction,
+    }),
     controller: createController({
       model: ctx.model,
       build: (next) => {

package/src/orchestrate/prisma/orchestratePrismaSchemas.ts

@@ -15,6 +15,7 @@ import { IAutoBePrismaSchemaApplication } from "./structures/IAutoBePrismaSchema
 
 export async function orchestratePrismaSchemas<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
+  instruction: string,
   componentList: AutoBePrisma.IComponent[],
 ): Promise<AutoBePrismaSchemasEvent[]> {
   const start: Date = new Date();
@@ -29,6 +30,7 @@ export async function orchestratePrismaSchemas<Model extends ILlmSchema.Model>(
         .map((c) => c.tables)
         .flat();
       const event: AutoBePrismaSchemasEvent = await process(ctx, {
+        instruction,
         component,
         otherTables,
         start,
@@ -45,6 +47,7 @@ export async function orchestratePrismaSchemas<Model extends ILlmSchema.Model>(
 async function process<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   props: {
+    instruction: string;
     component: AutoBePrisma.IComponent;
     otherTables: string[];
     start: Date;
@@ -58,16 +61,18 @@ async function process<Model extends ILlmSchema.Model>(
   };
   const { tokenUsage } = await ctx.conversate({
     source: "prismaSchemas",
-    histories: transformPrismaSchemaHistories(
-      ctx
-        .state()
-        .analyze?.files.map((file) => ({ [file.filename]: file.content }))
-        .reduce((acc, cur) => {
-          return Object.assign(acc, cur);
-        }, {}) ?? {},
-      props.component,
-      props.otherTables,
-    ),
+    histories: transformPrismaSchemaHistories({
+      analysis:
+        ctx
+          .state()
+          .analyze?.files.map((file) => ({ [file.filename]: file.content }))
+          .reduce((acc, cur) => {
+            return Object.assign(acc, cur);
+          }, {}) ?? {},
+      targetComponent: props.component,
+      otherTables: props.otherTables,
+      instruction: props.instruction,
+    }),
     controller: createController(ctx, {
       targetComponent: props.component,
       otherTables: props.otherTables,