@autobe/agent 0.17.1 → 0.19.1

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/histories/transformRealizeAuthorization.ts

@@ -0,0 +1,48 @@
+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";
+
+export const transformRealizeAuthorizationHistories = <
+  Model extends ILlmSchema.Model,
+>(
+  ctx: AutoBeContext<Model>,
+  role: AutoBeAnalyzeRole,
+): Array<
+  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+> => {
+  return [
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.REALIZE_AUTHORIZATION,
+    },
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: [
+        "## Role",
+        "```json",
+        JSON.stringify(role),
+        "```",
+        "",
+        "## Prisma Schema",
+        "",
+        JSON.stringify(ctx.state().prisma?.schemas),
+        "",
+        "## Component Naming Convention",
+        "",
+        "Please follow this naming convention for the authorization components:",
+        "",
+        `- 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[],
@@ -38,33 +40,29 @@ export const transformRealizeAuthorizationCorrectHistories = (
         "## Generated TypeScript Code",
         "",
         "```json",
-        `${JSON.stringify(
-          {
-            provider: {
-              location: auth.provider.location,
-              name: auth.provider.name,
-              content: auth.provider.content,
-            },
-            decorator: {
-              location: auth.decorator.location,
-              name: auth.decorator.name,
-              content: auth.decorator.content,
-            },
-            payload: {
-              location: auth.payload.location,
-              name: auth.payload.name,
-              content: auth.payload.content,
-            },
-          } satisfies Omit<AutoBeRealizeAuthorization, "role">,
-          null,
-          2,
-        )}`,
+        `${JSON.stringify({
+          provider: {
+            location: auth.provider.location,
+            name: auth.provider.name,
+            content: auth.provider.content,
+          },
+          decorator: {
+            location: auth.decorator.location,
+            name: auth.decorator.name,
+            content: auth.decorator.content,
+          },
+          payload: {
+            location: auth.payload.location,
+            name: auth.payload.name,
+            content: auth.payload.content,
+          },
+        } satisfies Omit<AutoBeRealizeAuthorization, "role">)}`,
         "```",
         "",
         "## Prisma Schema",
         "",
         "```json",
-        `${JSON.stringify(ctx.state().prisma?.schemas, null, 2)}`,
+        `${JSON.stringify(ctx.state().prisma?.schemas)}`,
         "```",
         "",
         "## File Paths",
@@ -78,7 +76,7 @@ export const transformRealizeAuthorizationCorrectHistories = (
         "Fix the compilation error in the provided code.",
         "",
         "```json",
-        JSON.stringify(diagnostics, null, 2),
+        JSON.stringify(diagnostics),
         "```",
         "## Component Naming Convention",
         "",
@@ -86,9 +84,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/histories/transformRealizeCorrectHistories.ts

@@ -0,0 +1,49 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import {
+  AutoBeRealizeAuthorization,
+  IAutoBeTypeScriptCompileResult,
+} 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";
+import { transformRealizeWriteHistories } from "./transformRealizeWriteHistories";
+
+export function transformRealizeCorrectHistories(props: {
+  state: AutoBeState;
+  scenario: IAutoBeRealizeScenarioApplication.IProps;
+  artifacts: IAutoBeTestScenarioArtifacts;
+  authorization: AutoBeRealizeAuthorization | null;
+  totalAuthorizations: AutoBeRealizeAuthorization[];
+  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),
+        "",
+      ].join("\n"),
+      created_at: new Date().toISOString(),
+    },
+    {
+      id: v4(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.REALIZE_CORRECT,
+      created_at: new Date().toISOString(),
+    },
+  ];
+}