@autobe/agent 0.16.1 → 0.18.0

package/lib/orchestrate/prisma/structures/IAutoBePrismaSchemaApplication.d.ts

@@ -0,0 +1,99 @@
+import { AutoBePrisma } from "@autobe/interface";
+import { tags } from "typia";
+export interface IAutoBePrismaSchemaApplication {
+    /**
+     * Generates comprehensive Prisma schema files based on detailed requirements
+     * analysis.
+     *
+     * 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.
+     *
+     * @param props Properties containing the file
+     */
+    makePrismaSchemaFile(props: IAutoBePrismaSchemaApplication.IProps): void;
+}
+export declare namespace IAutoBePrismaSchemaApplication {
+    interface IProps {
+        /**
+         * 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
+         * implementation.
+         *
+         * **Key Considerations:**
+         *
+         * - **Assignment Validation**: Extract targetComponent.tables as the 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
+         *   ({table1}_{table2})
+         * - **Materialized Views**: Identify needs for mv_ prefixed denormalized
+         *   tables
+         *
+         * Workflow: Component analysis → Strategic planning → Design rationale
+         */
+        plan: string;
+        /**
+         * Production-ready Prisma schema models generated based on the strategic
+         * plan.
+         *
+         * 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:**
+         *
+         * - **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: 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
+         *
+         * The generated models will undergo review by a separate specialized agent
+         * to ensure compliance with all requirements and best practices.
+         */
+        models: AutoBePrisma.IModel[] & tags.MinItems<1>;
+    }
+}

package/lib/orchestrate/realize/histories/transformRealizeAuthorization.d.ts

@@ -0,0 +1,5 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeAnalyzeRole } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../../context/AutoBeContext";
+export declare const transformRealizeAuthorizationHistories: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, role: AutoBeAnalyzeRole) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/orchestrate/realize/histories/transformRealizeAuthorizationCorrectHistories.d.ts

@@ -0,0 +1,5 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeRealizeAuthorization, IAutoBeTypeScriptCompileResult } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../../context/AutoBeContext";
+export declare const transformRealizeAuthorizationCorrectHistories: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, auth: AutoBeRealizeAuthorization, templateFiles: Record<string, string>, diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[]) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/orchestrate/realize/histories/transformRealizeCoderHistories.d.ts

@@ -0,0 +1,7 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeRealizeAuthorization, IAutoBeTypeScriptCompileResult } from "@autobe/interface";
+import { AutoBeState } from "../../../context/AutoBeState";
+import { IAutoBeTestScenarioArtifacts } from "../../test/structures/IAutoBeTestScenarioArtifacts";
+import { IAutoBeRealizeScenario } from "../orchestrateRealizeScenario";
+import { IAutoBeRealizeCompile } from "../structures/IAutoBeRealizeCompile";
+export declare const transformRealizeCoderHistories: (state: AutoBeState, previousCodes: IAutoBeRealizeCompile.Success[], props: IAutoBeRealizeScenario, artifacts: IAutoBeTestScenarioArtifacts, previous: string | null, diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[], authorization?: AutoBeRealizeAuthorization) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/orchestrate/realize/histories/transformRealizeCorrectHistories.d.ts

@@ -0,0 +1,13 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeRealizeAuthorization, IAutoBeTypeScriptCompileResult } from "@autobe/interface";
+import { AutoBeState } from "../../../context/AutoBeState";
+import { IAutoBeTestScenarioArtifacts } from "../../test/structures/IAutoBeTestScenarioArtifacts";
+import { IAutoBeRealizeScenarioApplication } from "../structures/IAutoBeRealizeScenarioApplication";
+export declare function transformRealizeCorrectHistories(props: {
+    state: AutoBeState;
+    scenario: IAutoBeRealizeScenarioApplication.IProps;
+    artifacts: IAutoBeTestScenarioArtifacts;
+    authorization: AutoBeRealizeAuthorization | null;
+    code: string;
+    diagnostic: IAutoBeTypeScriptCompileResult.IDiagnostic;
+}): Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/orchestrate/realize/histories/transformRealizeWriteHistories.d.ts

@@ -0,0 +1,11 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeRealizeAuthorization } from "@autobe/interface";
+import { AutoBeState } from "../../../context/AutoBeState";
+import { IAutoBeTestScenarioArtifacts } from "../../test/structures/IAutoBeTestScenarioArtifacts";
+import { IAutoBeRealizeScenarioApplication } from "../structures/IAutoBeRealizeScenarioApplication";
+export declare const transformRealizeWriteHistories: (props: {
+    state: AutoBeState;
+    scenario: IAutoBeRealizeScenarioApplication.IProps;
+    artifacts: IAutoBeTestScenarioArtifacts;
+    authorization: AutoBeRealizeAuthorization | null;
+}) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/orchestrate/realize/internal/compile.d.ts

@@ -0,0 +1,7 @@
+import { AutoBeRealizeAuthorization, AutoBeRealizeValidateEvent, IAutoBeTypeScriptCompileResult } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../../context/AutoBeContext";
+export declare function compile<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, props: {
+    authorizations: AutoBeRealizeAuthorization[];
+    providers: Record<string, string>;
+}): Promise<IAutoBeTypeScriptCompileResult.ISuccess | AutoBeRealizeValidateEvent>;

package/lib/orchestrate/realize/orchestrateRealizeCorrect.d.ts

@@ -0,0 +1,9 @@
+import { AutoBeRealizeAuthorization, AutoBeRealizeCorrectEvent, IAutoBeTypeScriptCompileResult } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { IAutoBeRealizeScenarioApplication } from "./structures/IAutoBeRealizeScenarioApplication";
+export declare function orchestrateRealizeCorrect<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, authorization: AutoBeRealizeAuthorization | null, scenario: IAutoBeRealizeScenarioApplication.IProps, code: string, diagnostic: IAutoBeTypeScriptCompileResult.IDiagnostic, progress: IProgress): Promise<AutoBeRealizeCorrectEvent>;
+export interface IProgress {
+    total: number;
+    completed: number;
+}

package/lib/orchestrate/realize/orchestrateRealizeScenario.d.ts

@@ -0,0 +1,91 @@
+import { AutoBeOpenApi, AutoBeRealizeAuthorization } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { IAutoBeRealizeScenarioApplication } from "./structures/IAutoBeRealizeScenarioApplication";
+export interface IAutoBeRealizeScenario {
+    /**
+     * The name of the function to be generated.
+     *
+     * Derived from the Swagger path and method. The function name must be written
+     * in snake_case. It serves as the entry point in both code generation and
+     * test code.
+     *
+     * Once the function is generated, the function name and file name will be the
+     * same. The generated file will be located at
+     * `src/providers/${function_name}.ts`.
+     */
+    functionName: string;
+    /**
+     * Definition of path and query parameters extracted from the OpenAPI spec.
+     *
+     * Includes input values passed via URL path or query string. Used for type
+     * definitions, validation, and function signature construction.
+     */
+    parameters: AutoBeOpenApi.IParameter[];
+    /**
+     * Schema definition for the request body input.
+     *
+     * Extracted from the requestBody section of Swagger. Represents the input
+     * data passed in the body (e.g., JSON). Used for generating function
+     * arguments or DTOs.
+     */
+    inputSchema: AutoBeOpenApi.IRequestBody | null;
+    /**
+     * Schema definition for the response body.
+     *
+     * Extracted from the responses section of Swagger. Used to define the return
+     * type and expected output in test code.
+     */
+    outputSchema: AutoBeOpenApi.IResponseBody | null;
+    /**
+     * Natural language description of the function’s purpose.
+     *
+     * Extracted from the summary or description field of Swagger. Used for code
+     * documentation, test scenario generation, and conveying function intent.
+     */
+    description: string;
+    /**
+     * HTTP method information.
+     *
+     * Extracted from the Swagger operation method. Used to define the request
+     * type during code and test generation.
+     */
+    method: "get" | "post" | "put" | "delete" | "patch";
+    /**
+     * List of scenario descriptions for test code generation.
+     *
+     * Each scenario describes the expected behavior of the function under certain
+     * conditions. Used as a basis for TDD-style automated test generation.
+     */
+    testScenarios: string[];
+    /**
+     * Optional decorator event for customizing code generation behavior.
+     *
+     * Provides additional metadata or instructions that can modify how the
+     * function implementation is generated. Can include custom annotations,
+     * middleware configurations, or special handling directives that affect the
+     * final code output.
+     */
+    decoratorEvent?: AutoBeRealizeAuthorization;
+}
+/**
+ * Generates a planning result that defines what kind of function should be
+ * created, based solely on the provided Swagger (OpenAPI) operation — without
+ * using an LLM.
+ *
+ * This function analyzes the structure of the OpenAPI operation (such as the
+ * path, method, parameters, request/response schema, and descriptions) to
+ * determine the appropriate function name, input/output types, and purpose of
+ * the function.
+ *
+ * The result of this function (`RealizePlannerOutput`) will be passed to the
+ * next step in the AutoBE pipeline, which is responsible for generating the
+ * actual implementation code.
+ *
+ * @author Kakasoo
+ * @param ctx - AutoBE context including model and configuration
+ * @param operation - A single OpenAPI operation object to analyze and plan
+ * @returns A planning object containing all structural information needed to
+ *   generate the function
+ */
+export declare const orchestrateRealizeScenario: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, operation: AutoBeOpenApi.IOperation, authorization?: AutoBeRealizeAuthorization) => IAutoBeRealizeScenarioApplication.IProps;

package/lib/orchestrate/realize/orchestrateRealizeWrite.d.ts

@@ -0,0 +1,9 @@
+import { AutoBeRealizeAuthorization, AutoBeRealizeWriteEvent } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { IAutoBeRealizeScenarioApplication } from "./structures/IAutoBeRealizeScenarioApplication";
+export declare function orchestrateRealizeWrite<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, authorization: AutoBeRealizeAuthorization | null, scenario: IAutoBeRealizeScenarioApplication.IProps, progress: IProgress): Promise<AutoBeRealizeWriteEvent>;
+export interface IProgress {
+    total: number;
+    completed: number;
+}

package/lib/orchestrate/realize/structures/IAutoBeRealizeAuthorizationApplication.d.ts

@@ -1,3 +1,4 @@
+import { CamelPattern, PascalPattern } from "@autobe/interface";
 export interface IAutoBeRealizeAuthorizationApplication {
     createDecorator: (next: IAutoBeRealizeAuthorizationApplication.IProps) => void;
 }
@@ -32,8 +33,10 @@ export declare namespace IAutoBeRealizeAuthorizationApplication {
          * format (e.g., adminAuthorize, userAuthorize). This function will be
          * called by the decorator to verify JWT tokens and return authenticated
          * user information for the specified role.
+         *
+         * MUST use camelCase naming convention.
          */
-        name: string;
+        name: string & CamelPattern;
         /**
          * Complete TypeScript code for the authentication Provider function. Must
          * include: JWT token verification using jwtAuthorize function, role type
@@ -51,8 +54,10 @@ export declare namespace IAutoBeRealizeAuthorizationApplication {
          * decorator in Controller methods to automatically authenticate and
          * authorize users for the specific role, injecting the authenticated user
          * payload as a method parameter.
+         *
+         * MUST use PascalCase naming convention.
          */
-        name: string;
+        name: string & PascalPattern;
         /**
          * Complete TypeScript code for the authentication Decorator implementation.
          * Must include: SwaggerCustomizer integration to add bearer token security
@@ -69,8 +74,10 @@ export declare namespace IAutoBeRealizeAuthorizationApplication {
          * (e.g., AdminPayload, UserPayload). This type defines the structure of the
          * authenticated user data that will be injected into Controller methods
          * when using the decorator.
+         *
+         * MUST use PascalCase naming convention.
          */
-        name: string;
+        name: string & PascalPattern;
         /**
          * Complete TypeScript code for the Payload type interface in {Role}Payload
          * format (e.g., AdminPayload, UserPayload). Must include: id field with

package/lib/orchestrate/realize/structures/IAutoBeRealizeReviewApplication.d.ts

@@ -0,0 +1,79 @@
+import { IAutoBeRealizeWriteApplication } from "./IAutoBeRealizeWriteApplication";
+export interface IAutoBeRealizeCorrectApplication {
+    review: (props: IAutoBeRealizeCorrectApplication.IProps) => void;
+}
+export declare namespace IAutoBeRealizeCorrectApplication {
+    interface IProps extends IAutoBeRealizeWriteApplication.IProps {
+        /**
+         * Compilation Error Analysis and Resolution Strategy
+         *
+         * This field contains a detailed analysis of TypeScript compilation errors
+         * that occurred during the previous compilation attempt, along with
+         * specific strategies to resolve each error.
+         *
+         * The analysis MUST include:
+         *
+         * 📊 ERROR BREAKDOWN:
+         *
+         * - List of all TypeScript error codes encountered (e.g., TS2339, TS2345)
+         * - Exact error messages and the lines/files where they occurred
+         * - Categorization of errors by type (type mismatch, missing property, etc.)
+         *
+         * 🔍 ROOT CAUSE ANALYSIS:
+         *
+         * - Why each error occurred (e.g., incorrect type assumptions, missing
+         *   fields)
+         * - Relationship between errors (e.g., cascading errors from a single issue)
+         * - Common patterns identified across multiple errors
+         *
+         * 🛠 RESOLUTION STRATEGY:
+         *
+         * - Specific fixes for each error type
+         * - Priority order for addressing errors (fix critical errors first)
+         * - Alternative approaches if the direct fix is not possible
+         *
+         * 📝 SCHEMA VERIFICATION:
+         *
+         * - Re-verification of Prisma schema fields actually available
+         * - Identification of assumed fields that don't exist
+         * - Correct field types and relationships
+         *
+         * ⚠️ COMMON ERROR PATTERNS TO CHECK:
+         *
+         * - Using non-existent fields (e.g., deleted_at, created_by)
+         * - Type mismatches in Prisma operations
+         * - Incorrect date handling (using Date instead of string)
+         * - Missing required fields in create/update operations
+         * - Incorrect relation handling in nested operations
+         *
+         * 🎯 CORRECTION APPROACH:
+         *
+         * - Remove references to non-existent fields
+         * - Fix type conversions (especially dates with toISOStringSafe())
+         * - Simplify complex nested operations into separate queries
+         * - Add missing required fields
+         * - Use correct Prisma input types
+         *
+         * Example structure:
+         *
+         *     Errors Found:
+         *     1. TS2339: Property 'deleted_at' does not exist on type 'User'
+         *        - Cause: Field assumed but not in schema
+         *        - Fix: Remove all deleted_at references
+         *
+         *     2. TS2345: Type 'Date' is not assignable to type 'string'
+         *        - Cause: Direct Date assignment without conversion
+         *        - Fix: Use toISOStringSafe() for all date values
+         *
+         *     Resolution Plan:
+         *     1. First, remove all non-existent field references
+         *     2. Then, fix all date type conversions
+         *     3. Finally, adjust Prisma query structures
+         *
+         * This analysis ensures the review process addresses all compilation errors
+         * systematically and produces error-free code in the corrected
+         * implementation.
+         */
+        errorAnalysis: string;
+    }
+}

package/lib/orchestrate/realize/structures/IAutoBeRealizeScenarioApplication.d.ts

@@ -0,0 +1,38 @@
+import { AutoBeOpenApi, AutoBeRealizeAuthorization } from "@autobe/interface";
+export declare namespace IAutoBeRealizeScenarioApplication {
+    interface IProps {
+        /** The OpenAPI operation to be realized. */
+        operation: AutoBeOpenApi.IOperation;
+        /**
+         * The name of the function to be generated.
+         *
+         * Derived from the Swagger path and method. The function name must be
+         * written in snake_case. It serves as the entry point in both code
+         * generation and test code.
+         *
+         * Once the function is generated, the function name and file name will be
+         * the same. The generated file will be located at
+         * `src/providers/${function_name}.ts`.
+         */
+        functionName: string;
+        /** For example, `src/providers/${function_name}.ts`. */
+        location: string;
+        /**
+         * List of scenario descriptions for test code generation.
+         *
+         * Each scenario describes the expected behavior of the function under
+         * certain conditions. Used as a basis for TDD-style automated test
+         * generation.
+         */
+        testScenarios: string[];
+        /**
+         * Optional decorator event for customizing code generation behavior.
+         *
+         * Provides additional metadata or instructions that can modify how the
+         * function implementation is generated. Can include custom annotations,
+         * middleware configurations, or special handling directives that affect the
+         * final code output.
+         */
+        decoratorEvent?: AutoBeRealizeAuthorization;
+    }
+}