@autobe/agent 0.30.0-dev.20260315 → 0.30.1

package/src/orchestrate/realize/histories/transformRealizeCollectorPlanHistory.ts

@@ -1,64 +1,64 @@
-import { StringUtil } from "@autobe/utils";
-import { v7 } from "uuid";
-
-import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
-import { AutoBeState } from "../../../context/AutoBeState";
-import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
-import { AutoBePreliminaryController } from "../../common/AutoBePreliminaryController";
-
-export const transformRealizeCollectorPlanHistory = (props: {
-  state: AutoBeState;
-  preliminary: AutoBePreliminaryController<
-    | "analysisSections"
-    | "databaseSchemas"
-    | "interfaceSchemas"
-    | "interfaceOperations"
-  >;
-  dtoTypeName: string;
-}): IAutoBeOrchestrateHistory => {
-  return {
-    histories: [
-      {
-        id: v7(),
-        created_at: new Date().toISOString(),
-        type: "systemMessage",
-        text: AutoBeSystemPromptConstant.REALIZE_COLLECTOR_PLAN,
-      },
-      ...props.preliminary.getHistories(),
-      {
-        id: v7(),
-        created_at: new Date().toISOString(),
-        type: "assistantMessage",
-        text: StringUtil.trim`
-          I understand the task.
-
-          I need to analyze the given DTO type "${props.dtoTypeName}" and determine if it needs a collector.
-
-          **My approach**:
-          1. Analyze the DTO to determine if it's collectable or not
-          2. Generate a plan with ONE entry for this DTO
-
-          **For collectable DTOs**: Set databaseSchemaName to actual database table name
-          **For non-collectable DTOs**: Set databaseSchemaName to null
-
-          I will return exactly ONE plan entry for the given DTO.
-        `,
-      },
-    ],
-    userMessage: StringUtil.trim`
-      Analyze the DTO type "${props.dtoTypeName}" and create a collector plan entry.
-
-      **Your task**:
-      1. Determine if this DTO is collectable (maps to database table) or non-collectable
-      2. Generate a plan with exactly ONE entry for this DTO
-
-      **Remember**:
-      - Your plan must contain exactly ONE entry for "${props.dtoTypeName}"
-      - Collectable DTOs: Set databaseSchemaName to actual database table name
-      - Non-collectable DTOs: Set databaseSchemaName to null
-      - Do NOT include other DTOs in your plan
-
-      Create the plan for this DTO now.
-    `,
-  };
-};
+import { StringUtil } from "@autobe/utils";
+import { v7 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeState } from "../../../context/AutoBeState";
+import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
+import { AutoBePreliminaryController } from "../../common/AutoBePreliminaryController";
+
+export const transformRealizeCollectorPlanHistory = (props: {
+  state: AutoBeState;
+  preliminary: AutoBePreliminaryController<
+    | "analysisSections"
+    | "databaseSchemas"
+    | "interfaceSchemas"
+    | "interfaceOperations"
+  >;
+  dtoTypeName: string;
+}): IAutoBeOrchestrateHistory => {
+  return {
+    histories: [
+      {
+        id: v7(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: AutoBeSystemPromptConstant.REALIZE_COLLECTOR_PLAN,
+      },
+      ...props.preliminary.getHistories(),
+      {
+        id: v7(),
+        created_at: new Date().toISOString(),
+        type: "assistantMessage",
+        text: StringUtil.trim`
+          I understand the task.
+
+          I need to analyze the given DTO type "${props.dtoTypeName}" and determine if it needs a collector.
+
+          **My approach**:
+          1. Analyze the DTO to determine if it's collectable or not
+          2. Generate a plan with ONE entry for this DTO
+
+          **For collectable DTOs**: Set databaseSchemaName to actual database table name
+          **For non-collectable DTOs**: Set databaseSchemaName to null
+
+          I will return exactly ONE plan entry for the given DTO.
+        `,
+      },
+    ],
+    userMessage: StringUtil.trim`
+      Analyze the DTO type "${props.dtoTypeName}" and create a collector plan entry.
+
+      **Your task**:
+      1. Determine if this DTO is collectable (maps to database table) or non-collectable
+      2. Generate a plan with exactly ONE entry for this DTO
+
+      **Remember**:
+      - Your plan must contain exactly ONE entry for "${props.dtoTypeName}"
+      - Collectable DTOs: Set databaseSchemaName to actual database table name
+      - Non-collectable DTOs: Set databaseSchemaName to null
+      - Do NOT include other DTOs in your plan
+
+      Create the plan for this DTO now.
+    `,
+  };
+};

package/src/orchestrate/realize/histories/transformRealizeCollectorWriteHistory.ts

@@ -1,147 +1,147 @@
-import {
-  AutoBeDatabase,
-  AutoBeOpenApi,
-  AutoBeRealizeCollectorPlan,
-} from "@autobe/interface";
-import { StringUtil } from "@autobe/utils";
-import { v7 } from "uuid";
-
-import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
-import { AutoBeContext } from "../../../context/AutoBeContext";
-import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
-import { AutoBePreliminaryController } from "../../common/AutoBePreliminaryController";
-import { AutoBeRealizeCollectorProgrammer } from "../programmers/AutoBeRealizeCollectorProgrammer";
-
-export const transformRealizeCollectorWriteHistory = async (
-  ctx: AutoBeContext,
-  props: {
-    plan: AutoBeRealizeCollectorPlan;
-    preliminary: AutoBePreliminaryController<"databaseSchemas">;
-    neighbors: AutoBeRealizeCollectorPlan[];
-  },
-): Promise<IAutoBeOrchestrateHistory> => {
-  const application: AutoBeDatabase.IApplication =
-    ctx.state().database!.result.data;
-  const model: AutoBeDatabase.IModel = application.files
-    .map((f) => f.models)
-    .flat()
-    .find((m) => m.name === props.plan.databaseSchemaName)!;
-  const dto: Record<string, string> =
-    await AutoBeRealizeCollectorProgrammer.writeStructures(
-      ctx,
-      props.plan.dtoTypeName,
-    );
-  return {
-    histories: [
-      {
-        id: v7(),
-        created_at: new Date().toISOString(),
-        type: "systemMessage",
-        text: AutoBeSystemPromptConstant.REALIZE_COLLECTOR_WRITE,
-      },
-      ...props.preliminary.getHistories(),
-      {
-        id: v7(),
-        created_at: new Date().toISOString(),
-        type: "assistantMessage",
-        text: StringUtil.trim`
-          Here are the DTO types relevant with ${props.plan.dtoTypeName}:
-
-          \`\`\`json
-          ${JSON.stringify(dto)}
-          \`\`\`
-        `,
-      },
-      {
-        id: v7(),
-        created_at: new Date().toISOString(),
-        type: "assistantMessage",
-        text: StringUtil.trim`
-          ${getDeclaration({
-            plan: props.plan,
-            body: ctx.state().interface!.document.components.schemas[
-              props.plan.dtoTypeName
-            ],
-            model,
-            application,
-          })}
-
-          Here are the neighbor collectors you can utilize.
-
-          You can call their functions by using the function property of below.
-
-          \`\`\`json
-          ${JSON.stringify(
-            props.neighbors.map((n) => ({
-              function: `${AutoBeRealizeCollectorProgrammer.getName(n.dtoTypeName)}.collect()`,
-              dtoTypeName: n.dtoTypeName,
-              databaseSchemaName: n.databaseSchemaName,
-              references: n.references,
-            })),
-          )}
-          \`\`\`
-
-          At last, here is the list of database schema members you have to consider:
-
-          Member | Kind | Nullable
-          -------|------|----------
-          ${AutoBeRealizeCollectorProgrammer.getMappingMetadata({
-            application,
-            model,
-          })
-            .map((r) => `${r.member} | ${r.kind} | ${r.nullable}`)
-            .join("\n")}
-        `,
-      },
-    ],
-    userMessage: StringUtil.trim`
-      Create a collector module for the DTO type: ${props.plan.dtoTypeName}
-
-      **Plan Information from REALIZE_COLLECTOR_PLAN phase**:
-
-      - **Database Schema Name**: ${props.plan.databaseSchemaName}
-      - **Planning Reasoning**: ${props.plan.thinking}
-
-      **Your task**:
-
-      1. Use the provided database schema name: \`${props.plan.databaseSchemaName}\`
-      2. Analyze field mappings between DTO properties and database columns
-      3. Generate complete TypeScript code that includes:
-         - A namespace with collect() function
-         - Proper Prisma CreateInput types
-         - Type-safe field mappings from DTO to DB
-         - Handling of nested relationships if needed
-         - UUID generation for new records
-
-      Follow all coding standards and type safety rules. The database table name is already determined - use it directly.
-    `,
-  };
-};
-
-function getDeclaration(props: {
-  plan: AutoBeRealizeCollectorPlan;
-  body: AutoBeOpenApi.IJsonSchema;
-  model: AutoBeDatabase.IModel;
-  application: AutoBeDatabase.IApplication;
-}): string {
-  return StringUtil.trim`
-    Here is the declaration of the collector function for
-    the DTO type ${props.plan.dtoTypeName} and its corresponding
-    database schema ${props.plan.databaseSchemaName}.
-
-    ${
-      props.plan.references.length === 0
-        ? ""
-        : StringUtil.trim`
-          Also, as create DTO ${props.plan.dtoTypeName} does not include
-          every references required for the creation of the ${props.plan.databaseSchemaName}
-          record, you have to accept some references as function
-          parameters like below:
-        `
-    }
-
-    \`\`\`typescript
-    ${AutoBeRealizeCollectorProgrammer.writeTemplate(props)}
-    \`\`\`
-  `;
-}
+import {
+  AutoBeDatabase,
+  AutoBeOpenApi,
+  AutoBeRealizeCollectorPlan,
+} from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+import { v7 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeContext } from "../../../context/AutoBeContext";
+import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
+import { AutoBePreliminaryController } from "../../common/AutoBePreliminaryController";
+import { AutoBeRealizeCollectorProgrammer } from "../programmers/AutoBeRealizeCollectorProgrammer";
+
+export const transformRealizeCollectorWriteHistory = async (
+  ctx: AutoBeContext,
+  props: {
+    plan: AutoBeRealizeCollectorPlan;
+    preliminary: AutoBePreliminaryController<"databaseSchemas">;
+    neighbors: AutoBeRealizeCollectorPlan[];
+  },
+): Promise<IAutoBeOrchestrateHistory> => {
+  const application: AutoBeDatabase.IApplication =
+    ctx.state().database!.result.data;
+  const model: AutoBeDatabase.IModel = application.files
+    .map((f) => f.models)
+    .flat()
+    .find((m) => m.name === props.plan.databaseSchemaName)!;
+  const dto: Record<string, string> =
+    await AutoBeRealizeCollectorProgrammer.writeStructures(
+      ctx,
+      props.plan.dtoTypeName,
+    );
+  return {
+    histories: [
+      {
+        id: v7(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: AutoBeSystemPromptConstant.REALIZE_COLLECTOR_WRITE,
+      },
+      ...props.preliminary.getHistories(),
+      {
+        id: v7(),
+        created_at: new Date().toISOString(),
+        type: "assistantMessage",
+        text: StringUtil.trim`
+          Here are the DTO types relevant with ${props.plan.dtoTypeName}:
+
+          \`\`\`json
+          ${JSON.stringify(dto)}
+          \`\`\`
+        `,
+      },
+      {
+        id: v7(),
+        created_at: new Date().toISOString(),
+        type: "assistantMessage",
+        text: StringUtil.trim`
+          ${getDeclaration({
+            plan: props.plan,
+            body: ctx.state().interface!.document.components.schemas[
+              props.plan.dtoTypeName
+            ],
+            model,
+            application,
+          })}
+
+          Here are the neighbor collectors you can utilize.
+
+          You can call their functions by using the function property of below.
+
+          \`\`\`json
+          ${JSON.stringify(
+            props.neighbors.map((n) => ({
+              function: `${AutoBeRealizeCollectorProgrammer.getName(n.dtoTypeName)}.collect()`,
+              dtoTypeName: n.dtoTypeName,
+              databaseSchemaName: n.databaseSchemaName,
+              references: n.references,
+            })),
+          )}
+          \`\`\`
+
+          At last, here is the list of database schema members you have to consider:
+
+          Member | Kind | Nullable
+          -------|------|----------
+          ${AutoBeRealizeCollectorProgrammer.getMappingMetadata({
+            application,
+            model,
+          })
+            .map((r) => `${r.member} | ${r.kind} | ${r.nullable}`)
+            .join("\n")}
+        `,
+      },
+    ],
+    userMessage: StringUtil.trim`
+      Create a collector module for the DTO type: ${props.plan.dtoTypeName}
+
+      **Plan Information from REALIZE_COLLECTOR_PLAN phase**:
+
+      - **Database Schema Name**: ${props.plan.databaseSchemaName}
+      - **Planning Reasoning**: ${props.plan.thinking}
+
+      **Your task**:
+
+      1. Use the provided database schema name: \`${props.plan.databaseSchemaName}\`
+      2. Analyze field mappings between DTO properties and database columns
+      3. Generate complete TypeScript code that includes:
+         - A namespace with collect() function
+         - Proper Prisma CreateInput types
+         - Type-safe field mappings from DTO to DB
+         - Handling of nested relationships if needed
+         - UUID generation for new records
+
+      Follow all coding standards and type safety rules. The database table name is already determined - use it directly.
+    `,
+  };
+};
+
+function getDeclaration(props: {
+  plan: AutoBeRealizeCollectorPlan;
+  body: AutoBeOpenApi.IJsonSchema;
+  model: AutoBeDatabase.IModel;
+  application: AutoBeDatabase.IApplication;
+}): string {
+  return StringUtil.trim`
+    Here is the declaration of the collector function for
+    the DTO type ${props.plan.dtoTypeName} and its corresponding
+    database schema ${props.plan.databaseSchemaName}.
+
+    ${
+      props.plan.references.length === 0
+        ? ""
+        : StringUtil.trim`
+          Also, as create DTO ${props.plan.dtoTypeName} does not include
+          every references required for the creation of the ${props.plan.databaseSchemaName}
+          record, you have to accept some references as function
+          parameters like below:
+        `
+    }
+
+    \`\`\`typescript
+    ${AutoBeRealizeCollectorProgrammer.writeTemplate(props)}
+    \`\`\`
+  `;
+}

package/src/orchestrate/realize/histories/transformRealizeCorrectCastingHistory.ts

@@ -1,69 +1,69 @@
-import { AutoBeRealizeFunction } from "@autobe/interface";
-import { StringUtil } from "@autobe/utils";
-import { v7 } from "uuid";
-
-import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
-import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
-import { transformPreviousAndLatestCorrectHistory } from "../../common/histories/transformPreviousAndLatestCorrectHistory";
-import { IAutoBeRealizeFunctionFailure } from "../structures/IAutoBeRealizeFunctionFailure";
-
-export const transformRealizeCorrectCastingHistory = <
-  RealizeFunction extends AutoBeRealizeFunction,
->(props: {
-  template: string;
-  function: RealizeFunction;
-  failures: IAutoBeRealizeFunctionFailure<RealizeFunction>[];
-}): IAutoBeOrchestrateHistory => {
-  return {
-    histories: [
-      {
-        id: v7(),
-        created_at: new Date().toISOString(),
-        type: "systemMessage",
-        text: AutoBeSystemPromptConstant.COMMON_CORRECT_CASTING,
-      },
-      ...transformPreviousAndLatestCorrectHistory(
-        props.failures.map((f) => ({
-          script: f.function.content,
-          diagnostics: f.diagnostics,
-        })),
-      ),
-    ],
-    userMessage: StringUtil.trim`
-      Fix the TypeScript casting problems to resolve the compilation error.
-
-      Most casting errors are caused by type mismatches between Date types and
-      string & tags.Format<'date-time'>. To fix these:
-      - Use ONLY the pre-provided toISOStringSafe() function to convert Date to string
-      - Do NOT use .toISOString() method directly (use toISOStringSafe instead)
-      - Never use Date type directly in declarations or return values
-
-      You don't need to explain me anything, but just fix or give it up
-      immediately without any hesitation, explanation, and questions.
-
-      The instruction to write at first was as follows, and the code you received is the code you wrote according to this instruction.
-      When modifying, modify the entire code, but not the import statement.
-
-      Below is template code you wrote:
-
-      ${props.template}
-
-      Current code is as follows:
-
-      \`\`\`typescript
-      ${props.function.content}
-      \`\`\`
-
-      Also, never use typia.assert and typia.assertGuard like functions
-      to the Prisma types. Your mission is to fix the casting problem of
-      primitive types like string or number. Prisma type is not your scope.
-
-      If you take a mistake that casting the Prisma type with the typia.assert
-      function, it would be fallen into the infinite compilation due to extremely
-      complicated Prisma type. Note that, the typia.assert function is allowed
-      only in the individual property level string or literal type.
-
-      I repeat that, never assert the Prisma type. It's not your mission.
-    `,
-  };
-};
+import { AutoBeRealizeFunction } from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+import { v7 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
+import { transformPreviousAndLatestCorrectHistory } from "../../common/histories/transformPreviousAndLatestCorrectHistory";
+import { IAutoBeRealizeFunctionFailure } from "../structures/IAutoBeRealizeFunctionFailure";
+
+export const transformRealizeCorrectCastingHistory = <
+  RealizeFunction extends AutoBeRealizeFunction,
+>(props: {
+  template: string;
+  function: RealizeFunction;
+  failures: IAutoBeRealizeFunctionFailure<RealizeFunction>[];
+}): IAutoBeOrchestrateHistory => {
+  return {
+    histories: [
+      {
+        id: v7(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: AutoBeSystemPromptConstant.COMMON_CORRECT_CASTING,
+      },
+      ...transformPreviousAndLatestCorrectHistory(
+        props.failures.map((f) => ({
+          script: f.function.content,
+          diagnostics: f.diagnostics,
+        })),
+      ),
+    ],
+    userMessage: StringUtil.trim`
+      Fix the TypeScript casting problems to resolve the compilation error.
+
+      Most casting errors are caused by type mismatches between Date types and
+      string & tags.Format<'date-time'>. To fix these:
+      - Use ONLY the pre-provided toISOStringSafe() function to convert Date to string
+      - Do NOT use .toISOString() method directly (use toISOStringSafe instead)
+      - Never use Date type directly in declarations or return values
+
+      You don't need to explain me anything, but just fix or give it up
+      immediately without any hesitation, explanation, and questions.
+
+      The instruction to write at first was as follows, and the code you received is the code you wrote according to this instruction.
+      When modifying, modify the entire code, but not the import statement.
+
+      Below is template code you wrote:
+
+      ${props.template}
+
+      Current code is as follows:
+
+      \`\`\`typescript
+      ${props.function.content}
+      \`\`\`
+
+      Also, never use typia.assert and typia.assertGuard like functions
+      to the Prisma types. Your mission is to fix the casting problem of
+      primitive types like string or number. Prisma type is not your scope.
+
+      If you take a mistake that casting the Prisma type with the typia.assert
+      function, it would be fallen into the infinite compilation due to extremely
+      complicated Prisma type. Note that, the typia.assert function is allowed
+      only in the individual property level string or literal type.
+
+      I repeat that, never assert the Prisma type. It's not your mission.
+    `,
+  };
+};