@autobe/agent 0.28.0 → 0.29.0

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

@@ -1,100 +1,127 @@
 import { AutoBePrisma } from "@autobe/interface";
 import { tags } from "typia";
 
+import { IAutoBePreliminaryGetAnalysisFiles } from "../../common/structures/IAutoBePreliminaryGetAnalysisFiles";
+
 export interface IAutoBePrismaSchemaApplication {
   /**
-   * Generates comprehensive Prisma schema files based on detailed requirements
-   * analysis.
+   * Process schema generation task or preliminary data requests.
    *
-   * 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.
+   * Generates Prisma models for the target component following normalization
+   * principles and database design best practices.
    *
-   * @param props Properties containing the file
+   * @param props Request containing either preliminary data request or complete
+   *   task
    */
-  makePrismaSchemaFile(props: IAutoBePrismaSchemaApplication.IProps): void;
+  process(props: IAutoBePrismaSchemaApplication.IProps): void;
 }
 export namespace IAutoBePrismaSchemaApplication {
   export interface IProps {
+    /**
+     * Think before you act.
+     *
+     * Before requesting preliminary data or completing your task, reflect on your
+     * current state and explain your reasoning:
+     *
+     * For preliminary requests (getAnalysisFiles, getPrismaSchemas, etc.):
+     * - What critical information is missing that you don't already have?
+     * - Why do you need it specifically right now?
+     * - Be brief - state the gap, don't list everything you have.
+     *
+     * For completion (complete):
+     * - What key assets did you acquire?
+     * - What did you accomplish?
+     * - Why is it sufficient to complete?
+     * - Summarize - don't enumerate every single item.
+     *
+     * This reflection helps you avoid duplicate requests and premature completion.
+     */
+    thinking: string;
+
+    /**
+     * Type discriminator for the request.
+     *
+     * Determines which action to perform: preliminary data retrieval
+     * (getAnalysisFiles) or final schema generation (complete). When
+     * preliminary returns empty array, that type is removed from the union,
+     * physically preventing repeated calls.
+     */
+    request: IComplete | IAutoBePreliminaryGetAnalysisFiles;
+  }
+
+  /**
+   * Request to generate Prisma schema models.
+   *
+   * Executes schema generation to create production-ready database models
+   * following normalization principles, relationship patterns, and indexing
+   * strategies.
+   */
+  export interface IComplete {
+    /**
+     * Type discriminator for the request.
+     *
+     * Determines which action to perform: preliminary data retrieval or actual
+     * task execution. Value "complete" indicates this is the final task
+     * execution request.
+     */
+    type: "complete";
+
     /**
      * Strategic database design analysis and planning.
      *
-     * AI analyzes the target component and business requirements to formulate a
-     * comprehensive database design strategy. This planning phase is crucial
-     * for creating well-structured, normalized schemas that align with business
-     * objectives. The AI must define table structures, relationships, indexing
-     * strategies, and data integrity constraints before proceeding to schema
+     * Contains the database architecture strategy including table structures,
+     * relationships, normalization approach, indexing strategies, and business
+     * requirement mapping. This planning phase defines the blueprint for schema
      * implementation.
      *
-     * **Key Considerations:**
+     * Key planning aspects:
      *
-     * - **Assignment Validation**: Extract targetComponent.tables as the complete
+     * - Assignment validation: Extract targetComponent.tables as complete
      *   specification
-     * - **Table Count**: Must create exactly targetComponent.tables.length models
-     * - **Other Components**: Identify already-created tables for foreign key
-     *   references only
-     * - **Normalization**: Strict adherence to 1NF, 2NF, 3NF principles
-     * - **Snapshot Architecture**: Design for historical data preservation and
-     *   audit trails
-     * - **Junction Tables**: Plan M:N relationships with proper naming
+     * - Table count: Must create exactly targetComponent.tables.length models
+     * - Component references: Identify existing tables for foreign key
+     *   relationships
+     * - Normalization: Strict adherence to 1NF, 2NF, 3NF principles
+     * - Snapshot architecture: Design for historical data preservation
+     * - Junction tables: Plan M:N relationships with proper naming
      *   ({table1}_{table2})
-     * - **Materialized Views**: Identify needs for mv_ prefixed denormalized
-     *   tables
-     *
-     * Workflow: Component analysis → Strategic planning → Design rationale
+     * - Materialized views: Identify needs for mv_ prefixed denormalized tables
      */
     plan: string;
 
     /**
-     * Production-ready Prisma schema models generated based on the strategic
-     * plan.
+     * Production-ready Prisma schema models.
      *
-     * Contains a structured Abstract Syntax Tree (AST) representation of all
-     * database tables for the target component. Each model implements the
-     * planned table structure, relationships, indexes, and constraints using
-     * the AutoBePrisma.IModel interface. These models are designed to be
-     * production-ready from the initial generation, following all best
-     * practices and normalization principles.
+     * Complete AST representation of all database tables for the target
+     * component. Each model implements the planned structure, relationships,
+     * indexes, and constraints following best practices.
      *
-     * **Implementation Requirements:**
+     * Implementation requirements:
      *
-     * - **Model Count**: Exactly matches targetComponent.tables.length (plus any
-     *   junction tables)
-     * - **Table Names**: EXACT names from targetComponent.tables - no
-     *   modifications allowed
-     * - **Primary Keys**: Always UUID type with field name "id"
-     * - **Foreign Keys**: Proper IRelation configurations for all relationships
-     * - **Business Fields**: Only raw data fields - no calculated or derived
-     *   values
-     * - **Data Types**: Limited to: uuid, string, int, double, datetime, boolean,
-     *   uri
-     * - **Relationships**: Correct patterns for 1:1, 1:N, and M:N relationships
-     * - **Indexes**:
+     * - Model count: Exactly matches targetComponent.tables.length (plus junction
+     *   tables)
+     * - Table names: EXACT names from targetComponent.tables - no modifications
+     * - Primary keys: Always UUID type with field name "id"
+     * - Foreign keys: Proper IRelation configurations for all relationships
+     * - Business fields: Only raw data fields - no calculated or derived values
+     * - Data types: Limited to uuid, string, int, double, datetime, boolean, uri
+     * - Relationships: Correct patterns for 1:1, 1:N, and M:N
+     * - Indexes:
      *
      *   - UniqueIndexes: Business constraints and composite unique keys
-     *   - PlainIndexes: Multi-column query optimization (never single FK indexes)
+     *   - PlainIndexes: Multi-column query optimization (never single FK)
      *   - GinIndexes: Full-text search on appropriate string fields
-     * - **Materialized Views**: Tables prefixed with "mv_" have material flag set
-     *   to true
-     * - **Documentation**: Comprehensive English descriptions with business
-     *   context
-     *
-     * **Quality Standards:**
+     * - Materialized views: Tables prefixed with "mv_" have material flag set
+     * - Documentation: Comprehensive English descriptions with business context
      *
-     * - **Normalization**: Strict adherence to 3NF (Third Normal Form)
-     * - **No Denormalization**: Except in materialized views (mv_ tables)
-     * - **Referential Integrity**: All foreign keys reference valid existing
-     *   tables
-     * - **Temporal Fields**: Consistent created_at, updated_at, deleted_at
-     *   patterns
-     * - **Snapshot Support**: Proper historical data preservation where needed
-     * - **Performance Ready**: Optimized index strategy for expected query
-     *   patterns
+     * Quality standards:
      *
-     * The generated models will undergo review by a separate specialized agent
-     * to ensure compliance with all requirements and best practices.
+     * - Strict adherence to 3NF (Third Normal Form)
+     * - No denormalization except in materialized views (mv_ tables)
+     * - All foreign keys reference valid existing tables
+     * - Consistent created_at, updated_at, deleted_at patterns
+     * - Proper historical data preservation where needed
+     * - Optimized index strategy for expected query patterns
      */
     models: AutoBePrisma.IModel[] & tags.MinItems<1>;
   }

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

@@ -0,0 +1,89 @@
+import {
+  AutoBeRealizeAuthorization,
+  IAutoBeTypeScriptCompileResult,
+} from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+import { v7 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
+import { AutoBePreliminaryController } from "../../common/AutoBePreliminaryController";
+
+export const transformRealizeAuthorizationCorrectHistory = (props: {
+  authorization: AutoBeRealizeAuthorization;
+  template: Record<string, string>;
+  diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[];
+  preliminary: AutoBePreliminaryController<"prismaSchemas">;
+}): IAutoBeOrchestrateHistory => {
+  return {
+    histories: [
+      {
+        id: v7(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: AutoBeSystemPromptConstant.REALIZE_AUTHORIZATION_WRITE,
+      },
+      {
+        id: v7(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: AutoBeSystemPromptConstant.REALIZE_AUTHORIZATION_CORRECT,
+      },
+      ...props.preliminary.getHistories(),
+      {
+        id: v7(),
+        created_at: new Date().toISOString(),
+        type: "assistantMessage",
+        text: StringUtil.trim`
+          ## Generated TypeScript Code
+
+          \`\`\`json
+          ${JSON.stringify({
+            provider: {
+              location: props.authorization.provider.location,
+              name: props.authorization.provider.name,
+              content: props.authorization.provider.content,
+            },
+            decorator: {
+              location: props.authorization.decorator.location,
+              name: props.authorization.decorator.name,
+              content: props.authorization.decorator.content,
+            },
+            payload: {
+              location: props.authorization.payload.location,
+              name: props.authorization.payload.name,
+              content: props.authorization.payload.content,
+            },
+          } satisfies Omit<AutoBeRealizeAuthorization, "actor">)}
+          \`\`\`
+
+          ## File Paths
+
+          ${Object.keys(props.template)
+            .map((path) => `- ${path}`)
+            .join("\n")}
+
+          ## Compile Errors
+
+          Fix the compilation error in the provided code.
+
+          \`\`\`json
+          ${JSON.stringify(props.diagnostics)}
+          \`\`\`
+
+          ## Component Naming Convention
+
+          If the name of the component is not correct, please correct it.
+
+          Please follow this naming convention for the authorization components:
+
+          - Provider Name: ${props.authorization.actor.name.toLowerCase()}Authorize (e.g. ${props.authorization.actor.name.toLowerCase()}Authorize)
+          - Decorator Name: ${props.authorization.actor.name.charAt(0).toUpperCase() + props.authorization.actor.name.slice(1).toLowerCase()}Auth (e.g. ${props.authorization.actor.name.charAt(0).toUpperCase() + props.authorization.actor.name.slice(1).toLowerCase()}Auth)
+          - Payload Name: ${props.authorization.actor.name.charAt(0).toUpperCase() + props.authorization.actor.name.slice(1).toLowerCase()}Payload (e.g. ${props.authorization.actor.name.charAt(0).toUpperCase() + props.authorization.actor.name.slice(1).toLowerCase()}Payload)
+        `,
+      },
+    ],
+    userMessage:
+      "Fix the compile errors in the authorization components please",
+  };
+};

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

@@ -0,0 +1,45 @@
+import { AutoBeAnalyzeActor } from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+import { v7 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
+import { AutoBePreliminaryController } from "../../common/AutoBePreliminaryController";
+
+export const transformRealizeAuthorizationWriteHistory = (props: {
+  actor: AutoBeAnalyzeActor;
+  preliminary: AutoBePreliminaryController<"prismaSchemas">;
+}): IAutoBeOrchestrateHistory => {
+  return {
+    histories: [
+      {
+        id: v7(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: AutoBeSystemPromptConstant.REALIZE_AUTHORIZATION_WRITE,
+      },
+      ...props.preliminary.getHistories(),
+      {
+        id: v7(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: StringUtil.trim`
+          ## Actor
+
+          \`\`\`json
+          ${JSON.stringify(props.actor)}
+          \`\`\`
+
+          ## Component Naming Convention
+
+          Please follow this naming convention for the authorization components:
+
+          - Provider Name: ${props.actor.name}Authorize (e.g. ${props.actor.name}Authorize)
+          - Decorator Name: ${props.actor.name.charAt(0).toUpperCase() + props.actor.name.slice(1)}Auth (e.g. ${props.actor.name.charAt(0).toUpperCase() + props.actor.name.slice(1)}Auth)
+          - Payload Name: ${props.actor.name.charAt(0).toUpperCase() + props.actor.name.slice(1)}Payload (e.g. ${props.actor.name.charAt(0).toUpperCase() + props.actor.name.slice(1)}Payload)
+        `,
+      },
+    ],
+    userMessage: `Create authorization components for ${props.actor.name} actor please`,
+  };
+};

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

@@ -0,0 +1,85 @@
+import {
+  AutoBeRealizeAuthorization,
+  AutoBeRealizeFunction,
+} from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+import { ILlmSchema } from "@samchon/openapi";
+import { v7 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeContext } from "../../../context/AutoBeContext";
+import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
+import { transformPreviousAndLatestCorrectHistory } from "../../common/histories/transformPreviousAndLatestCorrectHistory";
+import { IAutoBeRealizeFunctionFailure } from "../structures/IAutoBeRealizeFunctionFailure";
+import { IAutoBeRealizeScenarioResult } from "../structures/IAutoBeRealizeScenarioResult";
+import { getRealizeWriteCodeTemplate } from "../utils/getRealizeWriteCodeTemplate";
+
+export const transformRealizeCorrectCastingHistory = <
+  Model extends ILlmSchema.Model,
+>(
+  ctx: AutoBeContext<Model>,
+  props: {
+    scenario: IAutoBeRealizeScenarioResult;
+    authorization: AutoBeRealizeAuthorization | undefined;
+    function: AutoBeRealizeFunction;
+    failures: IAutoBeRealizeFunctionFailure[];
+  },
+): 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:
+
+      ${getRealizeWriteCodeTemplate({
+        scenario: props.scenario,
+        schemas: ctx.state().interface!.document.components.schemas,
+        operation: props.scenario.operation,
+        authorization: props.authorization ?? null,
+      })}
+
+      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.
+    `,
+  };
+};

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

@@ -0,0 +1,77 @@
+import {
+  AutoBeRealizeAuthorization,
+  AutoBeRealizeFunction,
+} from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+import { ILlmSchema } from "@samchon/openapi";
+import { v7 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeContext } from "../../../context/AutoBeContext";
+import { AutoBeState } from "../../../context/AutoBeState";
+import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
+import { AutoBePreliminaryController } from "../../common/AutoBePreliminaryController";
+import { transformPreviousAndLatestCorrectHistory } from "../../common/histories/transformPreviousAndLatestCorrectHistory";
+import { IAutoBeRealizeFunctionFailure } from "../structures/IAutoBeRealizeFunctionFailure";
+import { IAutoBeRealizeScenarioResult } from "../structures/IAutoBeRealizeScenarioResult";
+import { getRealizeWriteCodeTemplate } from "../utils/getRealizeWriteCodeTemplate";
+import { transformRealizeWriteHistories } from "./transformRealizeWriteHistories";
+
+export function transformRealizeCorrectHistory<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  props: {
+    state: AutoBeState;
+    scenario: IAutoBeRealizeScenarioResult;
+    authorization: AutoBeRealizeAuthorization | null;
+    function: AutoBeRealizeFunction;
+    totalAuthorizations: AutoBeRealizeAuthorization[];
+    dto: Record<string, string>;
+    failures: IAutoBeRealizeFunctionFailure[];
+    preliminary: AutoBePreliminaryController<"prismaSchemas">;
+  },
+): IAutoBeOrchestrateHistory {
+  const writeHistories = transformRealizeWriteHistories(props);
+  return {
+    histories: [
+      ...writeHistories.histories,
+      {
+        id: v7(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: AutoBeSystemPromptConstant.COMMON_CORRECT_CASTING,
+      },
+      {
+        id: v7(),
+        type: "systemMessage",
+        text: AutoBeSystemPromptConstant.REALIZE_CORRECT,
+        created_at: new Date().toISOString(),
+      },
+      ...transformPreviousAndLatestCorrectHistory(
+        props.failures.map((f) => ({
+          script: f.function.content,
+          diagnostics: f.diagnostics,
+        })),
+      ),
+    ],
+    userMessage: StringUtil.trim`
+      Correct the TypeScript code implementation.
+
+      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:
+
+      ${getRealizeWriteCodeTemplate({
+        scenario: props.scenario,
+        schemas: ctx.state().interface!.document.components.schemas,
+        operation: props.scenario.operation,
+        authorization: props.authorization ?? null,
+      })}
+
+      Current code is as follows:
+      \`\`\`typescript
+      ${props.function.content}
+      \`\`\`
+    `,
+  };
+}