@autobe/agent 0.17.1 → 0.18.0

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

@@ -1,4 +1,5 @@
 import { AutoBePrisma } from "@autobe/interface";
+import { tags } from "typia";
 
 export interface IAutoBePrismaSchemaApplication {
   /**
@@ -18,7 +19,7 @@ export interface IAutoBePrismaSchemaApplication {
 export namespace IAutoBePrismaSchemaApplication {
   export interface IProps {
     /**
-     * Step 1: Strategic database design analysis and planning.
+     * 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
@@ -44,171 +45,57 @@ export namespace IAutoBePrismaSchemaApplication {
      *
      * Workflow: Component analysis → Strategic planning → Design rationale
      */
-    thinking: string;
+    plan: string;
 
     /**
-     * Step 2: Initial Prisma schema code implementation.
+     * Production-ready Prisma schema models generated based on the strategic
+     * plan.
      *
-     * AI generates the first working version of the Prisma schema based on the
-     * strategic plan. This draft must be syntactically correct Prisma Schema
-     * Language (PSL) code that implements all planned tables, relationships,
-     * and constraints. The schema should follow Prisma conventions while
-     * incorporating enterprise patterns like snapshot tables and materialized
-     * views.
+     * 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.
      *
      * **Implementation Requirements:**
      *
-     * - **Exact Table Names**: Use EXACT names from targetComponent.tables (NO
-     *   CHANGES)
-     * - **Valid PSL Syntax**: Proper model blocks, field definitions, and
-     *   directives
-     * - **Primary Keys**: Always UUID type with `@id` directive
-     * - **Foreign Keys**: UUID type following {target_model}_id naming pattern
-     * - **Data Types**: uuid, string, int, double, datetime, boolean, uri (no
-     *   pre-calculated fields)
-     * - **Relationships**: Proper `@relation` directives for 1:1, 1:N, M:N
-     *   patterns
-     * - **Descriptions**: Follow format with requirements mapping and business
-     *   purpose
-     * - **NO Prohibited Fields**: No totals, cached values, aggregates in regular
-     *   tables
-     *
-     * Workflow: Strategic plan → PSL implementation → Functional schema code
-     */
-    draft: string;
-
-    /**
-     * Step 3: Schema code review and quality assessment.
-     *
-     * AI performs a thorough review of the draft schema implementation,
-     * examining multiple quality dimensions to ensure production readiness.
-     * This review process identifies issues, suggests improvements, and
-     * validates compliance with best practices.
-     *
-     * **Review Dimensions:**
-     *
-     * **Syntax & Compilation:**
-     *
-     * - Prisma schema syntax errors and invalid directives
-     * - Model naming matches targetComponent.tables EXACTLY
-     * - Field type appropriateness (uuid for keys, no calculated fields)
-     * - Relationship definition correctness (`@relation` syntax)
-     *
-     * **Database Design Quality:**
-     *
-     * - **Normalization Compliance**:
-     *
-     *   - 1NF: Atomic values, no repeating groups
-     *   - 2NF: No partial dependencies on composite keys
-     *   - 3NF: No transitive dependencies
-     * - **Prohibited Fields Check**: No pre-calculated totals, cached values, or
-     *   aggregates in regular tables
-     * - **Snapshot Pattern**: Proper implementation for audit trails
-     * - **Junction Tables**: Correct naming ({table1}_{table2}) and structure
-     *
-     * **Index Strategy Validation:**
-     *
-     * - NO single foreign key indexes (Prisma auto-creates these)
-     * - Composite indexes for query patterns
-     * - Unique indexes for business constraints
-     * - GIN indexes for full-text search fields
-     *
-     * **Description Quality:**
-     *
-     * - Models include: requirement mapping, business purpose, relationships,
-     *   behaviors
-     * - Fields include: requirement aspect, business meaning, normalization
-     *   rationale
-     *
-     * Workflow: Draft schema → Systematic analysis → Specific improvements
-     */
-    review: string;
-
-    /**
-     * Step 4: Final production-ready Prisma schema code.
-     *
-     * AI produces the final, polished version of the Prisma schema
-     * incorporating all review feedback. This code represents the completed
-     * schema implementation, ready for database migration and production
-     * deployment. All identified issues must be resolved, and the schema must
-     * meet enterprise-grade quality standards.
-     *
-     * **Final Schema Characteristics:**
-     *
-     * - **Complete Coverage**: All targetComponent.tables implemented with exact
-     *   names
-     * - **Zero Errors**: Valid PSL syntax, no compilation warnings
-     * - **Proper Relationships**: All foreign keys reference existing tables
-     *   correctly
-     * - **Optimized Indexes**: Strategic indexes without redundant foreign key
-     *   indexes
-     * - **Full Normalization**: Strict 3NF compliance, denormalization only in
-     *   mv_ tables
-     * - **Enterprise Documentation**: Complete descriptions with business context
-     * - **Audit Support**: Proper snapshot patterns and temporal fields
-     *   (created_at, updated_at, deleted_at)
-     * - **Type Safety**: Consistent use of UUID for all keys, appropriate field
-     *   types
-     *
-     * Workflow: Review feedback → Schema refinement → Production-ready PSL code
-     */
-    final: string;
-
-    /**
-     * Step 5: Structured AST representation of the Prisma schema models.
-     *
-     * AI transforms the final Prisma schema code into a structured Abstract
-     * Syntax Tree (AST) representation using the AutoBePrisma.IModel interface.
-     * This involves critical reinterpretation and reclassification of the final
-     * code to conform to AST constraints.
-     *
-     * **CRITICAL: Reinterpretation & Post-Processing Required**
-     *
-     * The AI-generated final code may not directly map to valid AST structures
-     * due to:
-     *
-     * - Complex Prisma directives that need decomposition
-     * - Field attributes that require reclassification
-     * - Implicit relationships that need explicit AST representation
-     * - Schema-level constructs that must be distributed to models
-     *
-     * **Required Post-Processing Steps:**
-     *
-     * 1. **Field Reclassification**: Separate fields into primary, foreign, and
-     *    plain categories
-     * 2. **Relationship Extraction**: Convert `@relation` directives to IRelation
-     *    structures
-     * 3. **Index Decomposition**: Parse `@@index`, `@@unique` into appropriate
-     *    index arrays
-     * 4. **Type Normalization**: Map Prisma types to AST type enum values
-     * 5. **Constraint Resolution**: Convert schema constraints to AST properties
-     *
-     * **AST Structure Requirements:**
-     *
-     * - **Model Array**: Each table from targetComponent.tables as IModel
-     * - **Primary Field**: Always UUID type with name "id"
-     * - **Foreign Fields**: Proper IRelation configurations for all relationships
-     * - **Plain Fields**: Business fields with correct types (no calculated
-     *   fields)
+     * - **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**:
      *
      *   - UniqueIndexes: Business constraints and composite unique keys
-     *   - PlainIndexes: Query optimization (no single foreign key indexes)
-     *   - GinIndexes: Full-text search on string fields
-     * - **Material Flag**: true only for mv_ prefixed tables
-     *
-     * **Relationship Patterns in AST:**
-     *
-     * - 1:1: Foreign field with unique: true
-     * - 1:N: Foreign field with unique: false
-     * - M:N: Separate junction table model with composite indexes
-     *
-     * Workflow: Final PSL code → Reinterpretation → AST transformation →
-     * Structured models
+     *   - PlainIndexes: Multi-column query optimization (never single FK indexes)
+     *   - 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:**
+     *
+     * - **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
      *
-     * This structured representation serves as the ultimate deliverable for
-     * programmatic schema generation and manipulation.
+     * The generated models will undergo review by a separate specialized agent
+     * to ensure compliance with all requirements and best practices.
      */
-    models: AutoBePrisma.IModel[];
+    models: AutoBePrisma.IModel[] & tags.MinItems<1>;
   }
 }

package/src/orchestrate/realize/{transformRealizeAuthorization.ts → histories/transformRealizeAuthorization.ts}

@@ -1,13 +1,16 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeAnalyzeRole } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
 import { v4 } from "uuid";
 
-import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
-import { AutoBeContext } from "../../context/AutoBeContext";
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeContext } from "../../../context/AutoBeContext";
 
-export const transformRealizeAuthorizationHistories = (
-  ctx: AutoBeContext<ILlmSchema.Model>,
-  role: string,
+export const transformRealizeAuthorizationHistories = <
+  Model extends ILlmSchema.Model,
+>(
+  ctx: AutoBeContext<Model>,
+  role: AutoBeAnalyzeRole,
 ): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
 > => {
@@ -24,8 +27,9 @@ export const transformRealizeAuthorizationHistories = (
       type: "systemMessage",
       text: [
         "## Role",
-        "",
-        role,
+        "```json",
+        JSON.stringify(role),
+        "```",
         "",
         "## Prisma Schema",
         "",
@@ -35,9 +39,9 @@ export const transformRealizeAuthorizationHistories = (
         "",
         "Please follow this naming convention for the authorization components:",
         "",
-        `- Provider Name: ${role}Authorize (e.g. ${role}Authorize)`,
-        `- Decorator Name: ${role.charAt(0).toUpperCase() + role.slice(1)}Auth (e.g. ${role.charAt(0).toUpperCase() + role.slice(1)}Auth)`,
-        `- Payload Name: ${role.charAt(0).toUpperCase() + role.slice(1)}Payload (e.g. ${role.charAt(0).toUpperCase() + role.slice(1)}Payload)`,
+        `- Provider Name: ${role.name}Authorize (e.g. ${role.name}Authorize)`,
+        `- Decorator Name: ${role.name.charAt(0).toUpperCase() + role.name.slice(1)}Auth (e.g. ${role.name.charAt(0).toUpperCase() + role.name.slice(1)}Auth)`,
+        `- Payload Name: ${role.name.charAt(0).toUpperCase() + role.name.slice(1)}Payload (e.g. ${role.name.charAt(0).toUpperCase() + role.name.slice(1)}Payload)`,
       ].join("\n"),
     },
   ];

package/src/orchestrate/realize/{transformRealizeAuthorizationCorrectHistories.ts → histories/transformRealizeAuthorizationCorrectHistories.ts}

@@ -6,11 +6,13 @@ import {
 import { ILlmSchema } from "@samchon/openapi";
 import { v4 } from "uuid";
 
-import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
-import { AutoBeContext } from "../../context/AutoBeContext";
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeContext } from "../../../context/AutoBeContext";
 
-export const transformRealizeAuthorizationCorrectHistories = (
-  ctx: AutoBeContext<ILlmSchema.Model>,
+export const transformRealizeAuthorizationCorrectHistories = <
+  Model extends ILlmSchema.Model,
+>(
+  ctx: AutoBeContext<Model>,
   auth: AutoBeRealizeAuthorization,
   templateFiles: Record<string, string>,
   diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[],
@@ -86,9 +88,9 @@ export const transformRealizeAuthorizationCorrectHistories = (
         "",
         "Please follow this naming convention for the authorization components:",
         "",
-        `- Provider Name: ${auth.role.toLowerCase()}Authorize (e.g. ${auth.role.toLowerCase()}Authorize)`,
-        `- Decorator Name: ${auth.role.charAt(0).toUpperCase() + auth.role.slice(1).toLowerCase()}Auth (e.g. ${auth.role.charAt(0).toUpperCase() + auth.role.slice(1).toLowerCase()}Auth)`,
-        `- Payload Name: ${auth.role.charAt(0).toUpperCase() + auth.role.slice(1).toLowerCase()}Payload (e.g. ${auth.role.charAt(0).toUpperCase() + auth.role.slice(1).toLowerCase()}Payload)`,
+        `- Provider Name: ${auth.role.name.toLowerCase()}Authorize (e.g. ${auth.role.name.toLowerCase()}Authorize)`,
+        `- Decorator Name: ${auth.role.name.charAt(0).toUpperCase() + auth.role.name.slice(1).toLowerCase()}Auth (e.g. ${auth.role.name.charAt(0).toUpperCase() + auth.role.name.slice(1).toLowerCase()}Auth)`,
+        `- Payload Name: ${auth.role.name.charAt(0).toUpperCase() + auth.role.name.slice(1).toLowerCase()}Payload (e.g. ${auth.role.name.charAt(0).toUpperCase() + auth.role.name.slice(1).toLowerCase()}Payload)`,
       ].join("\n"),
     },
   ];

package/src/orchestrate/realize/{transformRealizeCoderHistories.ts → histories/transformRealizeCoderHistories.ts}

@@ -5,16 +5,16 @@ import {
 } from "@autobe/interface";
 import { v4 } from "uuid";
 
-import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
-import { AutoBeState } from "../../context/AutoBeState";
-import { IAutoBeTestScenarioArtifacts } from "../test/structures/IAutoBeTestScenarioArtifacts";
-import { RealizePlannerOutput } from "./orchestrateRealizePlanner";
-import { IAutoBeRealizeCompile } from "./structures/IAutoBeRealizeCompile";
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeState } from "../../../context/AutoBeState";
+import { IAutoBeTestScenarioArtifacts } from "../../test/structures/IAutoBeTestScenarioArtifacts";
+import { IAutoBeRealizeScenario } from "../orchestrateRealizeScenario";
+import { IAutoBeRealizeCompile } from "../structures/IAutoBeRealizeCompile";
 
 export const transformRealizeCoderHistories = (
   state: AutoBeState,
   previousCodes: IAutoBeRealizeCompile.Success[],
-  props: RealizePlannerOutput,
+  props: IAutoBeRealizeScenario,
   artifacts: IAutoBeTestScenarioArtifacts,
   previous: string | null,
   diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[],

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

@@ -0,0 +1,47 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import {
+  AutoBeRealizeAuthorization,
+  IAutoBeTypeScriptCompileResult,
+} from "@autobe/interface";
+import { v4 } from "uuid";
+
+import { AutoBeState } from "../../../context/AutoBeState";
+import { IAutoBeTestScenarioArtifacts } from "../../test/structures/IAutoBeTestScenarioArtifacts";
+import { IAutoBeRealizeScenarioApplication } from "../structures/IAutoBeRealizeScenarioApplication";
+import { transformRealizeWriteHistories } from "./transformRealizeWriteHistories";
+
+export function transformRealizeCorrectHistories(props: {
+  state: AutoBeState;
+  scenario: IAutoBeRealizeScenarioApplication.IProps;
+  artifacts: IAutoBeTestScenarioArtifacts;
+  authorization: AutoBeRealizeAuthorization | null;
+  code: string;
+  diagnostic: IAutoBeTypeScriptCompileResult.IDiagnostic;
+}): Array<
+  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+> {
+  return [
+    ...transformRealizeWriteHistories(props),
+    {
+      id: v4(),
+      type: "assistantMessage",
+      text: [
+        `Below is the code you made before. It's also something to review.`,
+        "```typescript",
+        props.code,
+        "```",
+        `The code has a compilation error:`,
+        "```json",
+        JSON.stringify(props.diagnostic, null, 2),
+        "",
+      ].join("\n"),
+      created_at: new Date().toISOString(),
+    },
+    {
+      id: v4(),
+      type: "systemMessage",
+      text: `You are an expert TypeScript developer. You will review the code and correct`,
+      created_at: new Date().toISOString(),
+    },
+  ];
+}

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

@@ -0,0 +1,184 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeRealizeAuthorization } from "@autobe/interface";
+import { v4 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeState } from "../../../context/AutoBeState";
+import { IAutoBeTestScenarioArtifacts } from "../../test/structures/IAutoBeTestScenarioArtifacts";
+import { IAutoBeRealizeScenarioApplication } from "../structures/IAutoBeRealizeScenarioApplication";
+
+export const transformRealizeWriteHistories = (props: {
+  state: AutoBeState;
+  scenario: IAutoBeRealizeScenarioApplication.IProps;
+  artifacts: IAutoBeTestScenarioArtifacts;
+  authorization: AutoBeRealizeAuthorization | null;
+}): Array<
+  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+> => {
+  const [operation] = props.artifacts.document.operations;
+
+  const propsFields: string[] = [];
+
+  // payload 추가
+  if (props.authorization && operation.authorizationRole) {
+    propsFields.push(
+      `${operation.authorizationRole}: ${props.authorization.payload.name};`,
+    );
+  }
+
+  // parameters 추가
+  operation.parameters.forEach((parameter) => {
+    const format =
+      "format" in parameter.schema
+        ? ` & tags.Format<'${parameter.schema.format}'>`
+        : "";
+    propsFields.push(`${parameter.name}: ${parameter.schema.type}${format};`);
+  });
+
+  // body 추가
+  if (operation.requestBody?.typeName) {
+    propsFields.push(`body: ${operation.requestBody.typeName};`);
+  }
+
+  const input =
+    propsFields.length > 0
+      ? `props: {\n${propsFields.map((field) => `  ${field}`).join("\n")}\n}`
+      : `// No props parameter needed - function should have no parameters`;
+
+  if (props.state.analyze === null)
+    return [
+      {
+        id: v4(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: [
+          "Requirement analysis is not yet completed.",
+          "Don't call the any tool function,",
+          "but say to process the requirement analysis.",
+        ].join(" "),
+      },
+    ];
+  else if (props.state.prisma === null)
+    return [
+      {
+        id: v4(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: [
+          "Prisma DB schema generation is not yet completed.",
+          "Don't call the any tool function,",
+          "but say to process the Prisma DB schema generation.",
+        ].join(" "),
+      },
+    ];
+  else if (props.state.analyze.step !== props.state.prisma.step)
+    return [
+      {
+        id: v4(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: [
+          "Prisma DB schema generation has not been updated",
+          "for the latest requirement analysis.",
+          "Don't call the any tool function,",
+          "but say to re-process the Prisma DB schema generation.",
+        ].join(" "),
+      },
+    ];
+  else if (props.state.prisma.compiled.type !== "success")
+    return [
+      {
+        id: v4(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: [
+          "Prisma DB schema generation has not been updated",
+          "for the latest requirement analysis.",
+          "Don't call the any tool function,",
+          "but say to re-process the Prisma DB schema generation.",
+        ].join(" "),
+      },
+    ];
+  else if (props.state.interface === null)
+    return [
+      {
+        id: v4(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: [
+          "Interface generation is not yet completed.",
+          "Don't call the any tool function,",
+          "but say to process the interface generation.",
+        ].join(" "),
+      },
+    ];
+
+  return [
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.REALIZE_CODER_TOTAL,
+    },
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.REALIZE_CODER_ARTIFACT.replaceAll(
+        `{prisma_schemas}`,
+        JSON.stringify(props.state.prisma.schemas),
+      )
+        .replaceAll(`{artifacts_sdk}`, JSON.stringify(props.artifacts.sdk))
+        .replaceAll(`{artifacts_dto}`, JSON.stringify(props.artifacts.dto))
+        .replaceAll(`{input}`, input),
+    },
+
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: [
+        "Write new code based on the following operation.",
+        "```json",
+        JSON.stringify(props.scenario),
+        "```",
+      ].join("\n"),
+    },
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "assistantMessage",
+      text: [
+        `I understand your request.`,
+        ``,
+        `To summarize:`,
+        `- I must **never use the native \`Date\` type** in any code or type definitions.`,
+        `- Instead, all date and datetime values must be handled as \`string & tags.Format<'date-time'>\`.`,
+        `- This rule is **strict** and applies everywhere, including domain types, API inputs/outputs, and Prisma models.`,
+        `- Even if a library or tool returns a \`Date\`, I must convert it to the correct string format before use.`,
+        ``,
+        `Especially regarding the \`Date\` type: I understand that using it can lead to type inconsistency and runtime issues, so I will completely avoid it in all circumstances.`,
+        ``,
+        `I'll make sure to follow all these rules strictly. Let’s proceed with this in mind.`,
+      ].join("\n"),
+    },
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "assistantMessage",
+      text: [
+        `I understand your request.`,
+        ``,
+        `To summarize:`,
+        `- I must **never use the native \`Date\` type** in any code or type definitions.`,
+        `- Instead, all date and datetime values must be handled as \`string & tags.Format<'date-time'>\`.`,
+        `- This rule is **strict** and applies everywhere, including domain types, API inputs/outputs, and Prisma models.`,
+        `- Even if a library or tool returns a \`Date\`, I must convert it to the correct string format before use.`,
+        ``,
+        `Especially regarding the \`Date\` type: I understand that using it can lead to type inconsistency and runtime issues, so I will completely avoid it in all circumstances.`,
+        ``,
+        `I'll make sure to follow all these rules strictly. Let’s proceed with this in mind.`,
+      ].join("\n"),
+    },
+  ];
+};

package/src/orchestrate/realize/internal/compile.ts

@@ -0,0 +1,84 @@
+import {
+  AutoBeRealizeAuthorization,
+  AutoBeRealizeValidateEvent,
+  IAutoBeTypeScriptCompileResult,
+} from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+
+import { AutoBeContext } from "../../../context/AutoBeContext";
+import { IAutoBeRealizeCompile } from "../structures/IAutoBeRealizeCompile";
+
+export async function compile<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  props: {
+    authorizations: AutoBeRealizeAuthorization[];
+    providers: Record<string, string>;
+  },
+): Promise<
+  IAutoBeTypeScriptCompileResult.ISuccess | AutoBeRealizeValidateEvent
+> {
+  const prisma = ctx.state().prisma?.compiled;
+  const payloads: Record<string, string> = Object.fromEntries(
+    props.authorizations.map((el) => [el.payload.location, el.payload.content]),
+  );
+  const templateFiles = await getTemplates(ctx);
+  const nodeModules = prisma?.type === "success" ? prisma.nodeModules : {};
+  const compiler = await ctx.compiler();
+  const compiled = await compiler.typescript.compile({
+    files: {
+      ...nodeModules,
+      ...payloads,
+      ...Object.fromEntries(
+        Object.entries(await ctx.files({ dbms: "sqlite" })).filter(([key]) =>
+          key.startsWith("src"),
+        ),
+      ),
+      ...Object.fromEntries(
+        templateFiles.map((file) => [file.location, file.content]),
+      ),
+      ...props.providers,
+    },
+  });
+
+  if (compiled.type === "success") {
+    return compiled;
+  }
+
+  const event: AutoBeRealizeValidateEvent = {
+    type: "realizeValidate",
+    result: compiled,
+    files: Object.fromEntries(
+      compiled.type === "failure"
+        ? compiled.diagnostics.map((d) => [d.file, d.code])
+        : [],
+    ),
+    step: ctx.state().analyze?.step ?? 0,
+    created_at: new Date().toISOString(),
+  };
+
+  return event;
+}
+
+/**
+ * Loads template files for the realize agent These files are essential for the
+ * realize coder to pass compilation
+ *
+ * @param ctx Context of agent
+ * @returns Template file infomations
+ */
+async function getTemplates<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+): Promise<IAutoBeRealizeCompile.CodeArtifact[]> {
+  const compiler = await ctx.compiler();
+  const templateFiles = await compiler.realize.getTemplate();
+  const pathnames = ["src/MyGlobal.ts", "src/util/toISOStringSafe.ts"] as const;
+
+  return pathnames.map((pathname): IAutoBeRealizeCompile.CodeArtifact => {
+    return {
+      content: templateFiles[pathname],
+      result: "success",
+      location: pathname,
+      role: null, // template files doesn't have role.
+    } as const;
+  });
+}