@autobe/agent 0.16.1 → 0.18.0

package/lib/agent/src/orchestrate/prisma/orchestratePrismaSchemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestratePrismaSchemas.js","sourceRoot":"","sources":["../../../../../src/orchestrate/prisma/orchestratePrismaSchemas.ts"],"names":[],"mappings":"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"}

package/lib/agent/src/orchestrate/prisma/structures/IAutoBePrismaComponentApplication.d.ts

@@ -0,0 +1,121 @@
+import { AutoBePrisma } from "@autobe/interface";
+import { tags } from "typia";
+export interface IAutoBePrismaComponentApplication {
+    /**
+     * Organizes database tables into domain-based components for Prisma schema
+     * generation.
+     *
+     * Takes business requirements and groups related tables into logical domains,
+     * with each component becoming a separate .prisma file.
+     */
+    extractComponents(props: IAutoBePrismaComponentApplication.IProps): void;
+}
+export declare namespace IAutoBePrismaComponentApplication {
+    interface IProps {
+        /**
+         * Initial thoughts on namespace classification criteria.
+         *
+         * Contains the AI agent's initial analysis and reasoning about how to
+         * organize tables into different business domains/namespaces.
+         *
+         * **Example:**
+         *
+         *     "Based on the business requirements, I identify several key domains:
+         *     - User-related entities should be grouped under 'Actors' namespace
+         *     - Product and sales information under 'Sales' namespace
+         *     - System configuration under 'Systematic' namespace"
+         */
+        thinking: string;
+        /**
+         * Review and refinement of the namespace classification.
+         *
+         * Contains the AI agent's review process, considering relationships between
+         * tables and potential improvements to the initial classification.
+         *
+         * **Example:**
+         *
+         *     "Upon review, I noticed that 'shopping_channel_categories' has strong
+         *     relationships with both channels and sales. However, since it primarily
+         *     defines the channel structure, it should remain in 'Systematic' namespace."
+         */
+        review: string;
+        /**
+         * Final decision on namespace classification.
+         *
+         * Contains the AI agent's final reasoning and rationale for the chosen
+         * namespace organization, explaining why this structure best serves the
+         * business requirements.
+         *
+         * **Example:**
+         *
+         *     "Final decision: Organize tables into 3 main namespaces:
+         *     1. Systematic - for channel and system configuration
+         *     2. Actors - for all user types (customers, citizens, administrators)
+         *     3. Sales - for product sales and related transactional data
+         *     This structure provides clear separation of concerns and follows DDD principles."
+         */
+        decision: string;
+        /**
+         * Array of domain components that group related database tables.
+         *
+         * Each component represents a business domain and becomes one Prisma schema
+         * file. Common domains include: Actors (users), Sales (products), Orders,
+         * Carts, etc.
+         *
+         * **Example:**
+         *
+         * ```typescript
+         * {
+         *   "components": [
+         *     {
+         *       "filename": "schema-02-systematic.prisma",
+         *       "namespace": "Systematic",
+         *       "thinking": "These tables all relate to system configuration and channel management. They form the foundation of the platform.",
+         *       "review": "Considering the relationships, shopping_channel_categories connects channels and sales, but it fundamentally defines channel structure.",
+         *       "rationale": "Grouping all system configuration tables together provides a clear foundation layer that other domains can reference.",
+         *       "tables": [
+         *         "shopping_channels",
+         *         "shopping_sections",
+         *         "shopping_channel_categories"
+         *       ]
+         *     },
+         *     {
+         *       "filename": "schema-03-actors.prisma",
+         *       "namespace": "Actors",
+         *       "thinking": "All user-related entities should be grouped together as they share authentication and identity patterns.",
+         *       "review": "While customers interact with sales, the customer entity itself is about identity, not transactions.",
+         *       "rationale": "This component groups all actor-related tables to maintain separation between identity management and business transactions.",
+         *       "tables": [
+         *         "shopping_customers",
+         *         "shopping_citizens",
+         *         "shopping_administrators"
+         *       ]
+         *     },
+         *     {
+         *       "filename": "schema-04-sales.prisma",
+         *       "namespace": "Sales",
+         *       "thinking": "Product catalog and sales-related tables belong together as they form the core commerce functionality.",
+         *       "review": "Sales snapshots are integral to the sales domain for tracking product history and price changes.",
+         *       "rationale": "Consolidating all sales-related tables enables coherent management of the entire product lifecycle.",
+         *       "tables": [
+         *         "shopping_sales",
+         *         "shopping_sale_snapshots",
+         *         "shopping_sale_units",
+         *         "shopping_sale_unit_options"
+         *       ]
+         *     }
+         *   ]
+         * }
+         * ```
+         *
+         * **Notes:**
+         *
+         * - Table names must follow snake_case convention with domain prefix (e.g.,
+         *   `shopping_customers`)
+         * - Each component becomes one `.prisma` file containing related models
+         * - Filename numbering indicates dependency order for schema generation
+         * - Namespace is used for documentation organization and domain grouping
+         */
+        components: AutoBePrisma.IComponent[] & tags.MinItems<1>;
+    }
+}

package/lib/agent/src/orchestrate/prisma/structures/IAutoBePrismaComponentApplication.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IAutoBePrismaComponentApplication.js.map

package/lib/agent/src/orchestrate/prisma/structures/IAutoBePrismaComponentApplication.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IAutoBePrismaComponentApplication.js","sourceRoot":"","sources":["../../../../../../src/orchestrate/prisma/structures/IAutoBePrismaComponentApplication.ts"],"names":[],"mappings":""}

package/lib/agent/src/orchestrate/prisma/structures/IAutoBePrismaCorrectApplication.d.ts

@@ -0,0 +1,142 @@
+import { AutoBePrisma } from "@autobe/interface";
+export interface IAutoBePrismaCorrectApplication {
+    /**
+     * Fixes validation errors in specific AutoBePrisma models while preserving
+     * ALL existing business logic and model descriptions.
+     *
+     * ## Core Rules
+     *
+     * 1. Fix ONLY validation errors in provided models - never remove business
+     *    descriptions
+     * 2. Apply minimal changes to error models only - preserve original design
+     *    intent
+     * 3. Return ONLY corrected models - unchanged models remain in original schema
+     * 4. Maintain referential integrity with unchanged models
+     *
+     * ## Targeted Scope
+     *
+     * - Process ONLY models with validation errors from IError[] array
+     * - Exclude models without errors from processing and output
+     * - Minimize context usage by returning corrected models only
+     * - Preserve unchanged models in their original state
+     *
+     * ## Fix Strategy
+     *
+     * - Resolve validation errors within specific models only
+     * - Fix field duplications, invalid references, and type mismatches
+     * - Update cross-model references without modifying target models
+     * - Ensure naming conventions and index rules compliance in corrected models
+     */
+    correctPrismaSchemaFiles(props: IAutoBePrismaCorrectApplication.IProps): void;
+}
+export declare namespace IAutoBePrismaCorrectApplication {
+    interface IProps {
+        /**
+         * Detailed execution plan for fixing `AutoBePrisma` validation errors in
+         * specific models.
+         *
+         * 🎯 Purpose: Enable systematic reasoning and step-by-step error resolution
+         * approach for targeted model validation issues
+         *
+         * 📋 Required Planning Content:
+         *
+         * 1. **Error Scope Analysis**
+         *
+         *    - List all validation errors from IAutoBePrismaValidation.IError[] array
+         *    - Extract unique table names from errors to identify affected models
+         *    - Categorize errors by type (field duplications, references, types,
+         *         indexes)
+         *    - Identify which models need correction vs. which remain unchanged
+         * 2. **Targeted Fix Strategy**
+         *
+         *    - Focus ONLY on models mentioned in validation errors
+         *    - Outline minimal changes needed for each affected model
+         *    - Plan cross-model reference updates (if any) without modifying non-error
+         *         models
+         *    - Ensure unchanged models maintain valid references to corrected models
+         * 3. **Model-Specific Fix Plan**
+         *
+         *    - Model-by-model modification plan for ONLY affected models
+         *    - Exact field additions, renames, or type corrections required
+         *    - Reference updates within corrected models only
+         *    - Index corrections limited to affected models
+         * 4. **Minimal Scope Validation**
+         *
+         *    - Confirm which models will be included in output (error models only)
+         *    - List models that will remain unchanged in original schema
+         *    - Identify cross-model dependencies without including unchanged models
+         *    - Preserve all business logic within corrected models
+         * 5. **Targeted Impact Assessment**
+         *
+         *    - Potential effects of fixes on unchanged models (reference validation)
+         *    - Verification points for corrected models only
+         *    - Ensure no new validation errors in targeted models
+         *    - Confirm minimal output scope compliance
+         *
+         * 💡 Example Planning Structure:
+         *
+         *     ## Error Scope
+         *     - Target Models: shopping_customers, shopping_orders (2 models only)
+         *     - Unchanged Models: All others remain in original schema
+         *
+         *     ## Targeted Fixes
+         *     - shopping_customers: Remove duplicate 'email' field
+         *     - shopping_orders: Update targetModel reference to 'shopping_customers'
+         *
+         *     ## Output Scope
+         *     - Return: Only shopping_customers and shopping_orders models
+         *     - Preserve: All other models unchanged in original schema
+         *
+         *     ## Cross-Model Impact
+         *     - Verify: shopping_orders still references shopping_customers correctly
+         *     - No changes needed in other models referencing these
+         */
+        planning: string;
+        /**
+         * ONLY the specific models that contain validation errors and need
+         * correction.
+         *
+         * 📥 Input Structure:
+         *
+         * - Contains ONLY models mentioned in IAutoBePrismaValidation.IError[] array
+         * - Each model has specific validation errors that need targeted correction
+         * - Models not mentioned in errors are excluded from this input
+         * - Represents minimal scope for error correction
+         *
+         * 🔍 Expected Validation Issues (Model-Specific):
+         *
+         * - Duplicate field/relation names within these specific models
+         * - Invalid foreign key references from these models to other models
+         * - Single foreign key fields in index arrays within these models
+         * - Invalid naming conventions within these specific models
+         * - Type validation errors in fields of these models
+         *
+         * 📝 Model Content Analysis (Targeted Scope):
+         *
+         * - Complete field definitions for each error model only
+         * - Relationships from these models (may reference unchanged models)
+         * - Indexes within these models that need correction
+         * - Business descriptions specific to these models
+         * - Cross-model references that need validation (read-only for targets)
+         *
+         * ⚠️ Processing Notes (Focused Approach):
+         *
+         * - Input contains ONLY models with validation errors
+         * - May reference other models not included in this input
+         * - Cross-model references must be validated but target models won't be
+         *   modified
+         * - Output should return corrected versions of ONLY these input models
+         * - All business logic and descriptions within these models must be preserved
+         * - Corrections must not break references from unchanged models
+         *
+         * 🎯 Correction Scope:
+         *
+         * - Fix validation errors within these specific models
+         * - Update internal model structure (fields, relations, indexes)
+         * - Correct references to external models (without modifying targets)
+         * - Maintain compatibility with unchanged models in the full schema
+         * - Return corrected versions of ONLY these models
+         */
+        models: AutoBePrisma.IModel[];
+    }
+}

package/lib/agent/src/orchestrate/prisma/structures/IAutoBePrismaCorrectApplication.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IAutoBePrismaCorrectApplication.js.map

package/lib/agent/src/orchestrate/prisma/structures/IAutoBePrismaCorrectApplication.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IAutoBePrismaCorrectApplication.js","sourceRoot":"","sources":["../../../../../../src/orchestrate/prisma/structures/IAutoBePrismaCorrectApplication.ts"],"names":[],"mappings":""}

package/lib/agent/src/orchestrate/prisma/structures/IAutoBePrismaReviewApplication.d.ts

@@ -0,0 +1,105 @@
+import { AutoBePrisma } from "@autobe/interface";
+export interface IAutoBePrismaReviewApplication {
+    /**
+     * Reviews and validates Prisma schema modifications to ensure compliance with
+     * database design best practices and business requirements.
+     *
+     * Performs comprehensive validation of proposed schema changes including
+     * normalization compliance, relationship integrity, performance optimization,
+     * and business logic alignment. The review process ensures all modifications
+     * maintain data consistency and follow enterprise-level database standards.
+     */
+    reviewSchemaFile(props: IAutoBePrismaReviewApplication.IProps): void;
+}
+export declare namespace IAutoBePrismaReviewApplication {
+    interface IProps {
+        /**
+         * Comprehensive review analysis of the proposed schema modifications.
+         *
+         * Contains the AI agent's detailed evaluation of the schema changes,
+         * including validation of normalization compliance, relationship integrity,
+         * index optimization, and business requirement alignment. The review
+         * identifies potential issues and confirms adherence to best practices.
+         *
+         * **Review Dimensions:**
+         *
+         * - **Normalization Validation**: Confirms 3NF compliance and proper data
+         *   structure
+         * - **Relationship Integrity**: Validates foreign key references and
+         *   cardinality
+         * - **Performance Optimization**: Reviews indexing strategy and query
+         *   patterns
+         * - **Business Logic Alignment**: Ensures schema supports all use cases
+         * - **Naming Conventions**: Verifies consistent naming patterns
+         * - **Data Type Consistency**: Confirms appropriate field types
+         * - **Temporal Field Handling**: Validates audit trail implementation
+         *
+         * **Example:**
+         *
+         *     "After reviewing the schema modifications:
+         *     1. All tables properly implement UUID primary keys
+         *     2. Foreign key relationships correctly reference existing models
+         *     3. Composite indexes optimize for common query patterns
+         *     4. Snapshot tables include proper temporal fields
+         *     5. Materialized views (mv_) contain appropriate denormalization
+         *     The schema follows all best practices and is ready for implementation."
+         */
+        review: string;
+        /**
+         * Strategic database design plan that guided the schema creation.
+         *
+         * Contains the original planning document that outlines the database
+         * architecture strategy, including table structures, relationships,
+         * normalization approach, and business requirement mapping. This plan
+         * serves as the blueprint for validating the implemented schema.
+         *
+         * **Planning Components:**
+         *
+         * - **Business Requirements**: Mapping of business needs to database
+         *   structures
+         * - **Table Design**: Entity definitions and attribute specifications
+         * - **Relationship Strategy**: Cardinality and referential integrity planning
+         * - **Normalization Approach**: Application of 1NF, 2NF, 3NF principles
+         * - **Performance Considerations**: Index strategy and query optimization
+         * - **Snapshot Architecture**: Temporal data handling and audit requirements
+         * - **Materialized Views**: Denormalization strategy for performance
+         *
+         * **Example:**
+         *
+         *     "Database Design Strategy:
+         *     Component: Sales Domain
+         *     Tables: shopping_sales, shopping_sale_snapshots, shopping_sale_units
+         *
+         *     Design Approach:
+         *     - Normalize product catalog to 3NF for data integrity
+         *     - Implement snapshot pattern for price history tracking
+         *     - Create composite indexes for product search queries
+         *     - Use materialized views for sales analytics dashboards"
+         */
+        plan: string;
+        /**
+         * Array of Prisma models that have been modified based on review feedback.
+         *
+         * Contains ONLY the models that required changes, not the entire schema.
+         * Each model represents a complete table definition with all fields,
+         * relationships, indexes, and documentation. These modifications will be
+         * applied to the models to produce the final implementation.
+         *
+         * **Model Requirements:**
+         *
+         * - **Complete Models**: Each entry must be a complete model definition
+         * - **Targeted Changes**: Only includes models that need modifications
+         * - **AST Compliance**: Follows AutoBePrisma.IModel interface structure
+         * - **Relationship Integrity**: All foreign keys reference valid models
+         * - **Index Optimization**: Strategic indexes without redundancy
+         * - **Documentation**: Comprehensive English descriptions
+         *
+         * **Notes:**
+         *
+         * - Models not included in this array remain unchanged from the models
+         * - The final schema merges these modifications with the original models
+         * - All modifications must resolve issues identified in the review
+         */
+        modifications: AutoBePrisma.IModel[];
+    }
+}

package/lib/agent/src/orchestrate/prisma/structures/IAutoBePrismaReviewApplication.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IAutoBePrismaReviewApplication.js.map

package/lib/agent/src/orchestrate/prisma/structures/IAutoBePrismaReviewApplication.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IAutoBePrismaReviewApplication.js","sourceRoot":"","sources":["../../../../../../src/orchestrate/prisma/structures/IAutoBePrismaReviewApplication.ts"],"names":[],"mappings":""}

package/lib/agent/src/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/agent/src/orchestrate/prisma/structures/IAutoBePrismaSchemaApplication.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IAutoBePrismaSchemaApplication.js.map

package/lib/agent/src/orchestrate/prisma/structures/IAutoBePrismaSchemaApplication.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IAutoBePrismaSchemaApplication.js","sourceRoot":"","sources":["../../../../../../src/orchestrate/prisma/structures/IAutoBePrismaSchemaApplication.ts"],"names":[],"mappings":""}

package/lib/agent/src/orchestrate/realize/ProviderCodeComparator.d.ts

@@ -0,0 +1,5 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+export declare namespace ProviderCodeComparator {
+    function hashCode(e: AutoBeOpenApi.IEndpoint): number;
+    function equals(x: AutoBeOpenApi.IEndpoint, y: AutoBeOpenApi.IEndpoint): boolean;
+}

package/lib/agent/src/orchestrate/realize/ProviderCodeComparator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProviderCodeComparator.js","sourceRoot":"","sources":["../../../../../src/orchestrate/realize/ProviderCodeComparator.ts"],"names":[],"mappings":";;;AACA,+BAA4B;AAE5B,IAAiB,sBAAsB,CAWtC;AAXD,WAAiB,sBAAsB;IACrC,SAAgB,QAAQ,CAAC,CAA0B;QACjD,OAAO,IAAA,WAAI,EAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC;IAChC,CAAC;IAFe,+BAAQ,WAEvB,CAAA;IAED,SAAgB,MAAM,CACpB,CAA0B,EAC1B,CAA0B;QAE1B,OAAO,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM,CAAC;IACpD,CAAC;IALe,6BAAM,SAKrB,CAAA;AACH,CAAC,EAXgB,sBAAsB,sCAAtB,sBAAsB,QAWtC"}

package/lib/agent/src/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/agent/src/orchestrate/realize/histories/transformRealizeAuthorization.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformRealizeAuthorizationHistories = void 0;
+const uuid_1 = require("uuid");
+const transformRealizeAuthorizationHistories = (ctx, role) => {
+    var _a;
+    return [
+        {
+            id: (0, uuid_1.v4)(),
+            created_at: new Date().toISOString(),
+            type: "systemMessage",
+            text: "# NestJS Authentication Provider & Decorator Generation AI Agent  \n\n## Naming Conventions\n\n### Notation Types\nThe following naming conventions (notations) are used throughout the system:\n- **camelCase**: First word lowercase, subsequent words capitalized (e.g., `userAccount`, `productItem`)\n- **PascalCase**: All words capitalized (e.g., `UserAccount`, `ProductItem`)\n- **snake_case**: All lowercase with underscores between words (e.g., `user_account`, `product_item`)\n\n### Specific Property Notations\n- **IAutoBeRealizeAuthorizationApplication.IProvider.name**: Use camelCase notation (format: `{Role.name(PascalCase)}Authorize`)\n- **IAutoBeRealizeAuthorizationApplication.IDecorator.name**: Use PascalCase notation (format: `{Role.name(PascalCase)}Auth`)\n- **IAutoBeRealizeAuthorizationApplication.IPayloadType.name**: Use PascalCase notation (format: `{Role.name(PascalCase)}Payload`)\n\nYou are a world-class NestJS expert and TypeScript developer. Your role is to automatically generate Provider functions and Decorators for JWT authentication based on given Role information and Prisma Schema.  \n\n## Core Mission  \n\nGenerate authentication Provider and Decorator code specialized for specific Roles based on Role information provided by users.  \n\n## Input Information  \n\n- **Role Name**: The authentication role to generate (e.g., admin, user, manager, etc.)  \n- **Prisma Schema**: Database table information.\n\n## File Structure\n\n**IMPORTANT: Understanding the file structure is crucial for correct import paths:**\n\n```\nsrc/\n\u251C\u2500\u2500 MyGlobal.ts\n\u251C\u2500\u2500 decorators/\n\u2502   \u251C\u2500\u2500 AdminAuth.ts\n\u2502   \u251C\u2500\u2500 UserAuth.ts\n\u2502   \u2514\u2500\u2500 payload/\n\u2502       \u251C\u2500\u2500 AdminPayload.ts\n\u2502       \u2514\u2500\u2500 UserPayload.ts\n\u2514\u2500\u2500 providers/\n    \u2514\u2500\u2500 authorize/\n        \u251C\u2500\u2500 jwtAuthorize.ts      \u2190 Shared JWT verification function\n        \u251C\u2500\u2500 adminAuthorize.ts    \u2190 Same directory as jwtAuthorize\n        \u2514\u2500\u2500 userAuthorize.ts     \u2190 Same directory as jwtAuthorize\n```\n\n## Code Generation Rules  \n\n### 1. Provider Function Generation Rules  \n\n- Function name: `{Role.name(PascalCase)}Authorize` format (e.g., adminAuthorize, userAuthorize)  \n- Must use the `jwtAuthorize` function for JWT token verification  \n- **\u26A0\uFE0F CRITICAL: Import jwtAuthorize using `import { jwtAuthorize } from \"./jwtAuthorize\";` (NOT from \"../../providers/authorize/jwtAuthorize\" or any other path)**\n- Verify payload type and check if `payload.type` matches the correct role  \n- Query database using `MyGlobal.prisma.{tableName}` format to fetch **only the authorization model itself** - do not include relations or business logic models (no `include` statements for profile, etc.)  \n- Verify that the user actually exists in the database  \n- Function return type should be `{Role.name(PascalCase)}Payload` interface  \n- Return the `payload` variable whenever feasible in provider functions.  \n- **Always check the Prisma schema for validation columns (e.g., `deleted_at`, status fields) within the authorization model and include them in the `where` clause to ensure the user is valid and active.**  \n\n### 2. Payload Interface Generation Rules  \n\n- Interface name: `{Role.name(PascalCase)}Payload` format (e.g., AdminPayload, UserPayload)  \n- Required fields:  \n  - `id: string & tags.Format<\"uuid\">`: User ID (UUID format)  \n  - `type: \"{role}\"`: Discriminator for role identification  \n- Additional fields should be generated according to Role characteristics and \"Prisma Schema\"  \n\n### 3. Decorator Generation Rules  \n\n- Decorator name: `{Role.name(PascalCase)}Auth` format (e.g., AdminAuth, UserAuth)  \n- Use SwaggerCustomizer to add bearer token security schema to API documentation  \n- Use createParamDecorator to implement actual authentication logic  \n- Use Singleton pattern to manage decorator instances  \n\n### 4. Code Style and Structure\n\n- Comply with TypeScript strict mode  \n- Utilize NestJS Exception classes (ForbiddenException, UnauthorizedException)  \n- Ensure type safety using typia tags  \n- Add appropriate JSDoc comments  \n\n## Reference Functions and Examples  \n\n### JWT Authentication Function  \n\n```typescript\n// File path: src/providers/authorize/jwtAuthorize.ts\nimport { ForbiddenException, UnauthorizedException } from \"@nestjs/common\";\nimport jwt from \"jsonwebtoken\";\n\nimport { MyGlobal } from \"../../MyGlobal\";\n\nexport function jwtAuthorize(props: {\n  request: {\n    headers: { authorization?: string };\n  };\n}) {\n  if (!props.request.headers.authorization)\n    throw new ForbiddenException(\"No token value exists\");\n  else if (\n    props.request.headers.authorization.startsWith(BEARER_PREFIX) === false\n  )\n    throw new UnauthorizedException(\"Invalid token\");\n\n  // PARSE TOKEN\n  try {\n    const token: string = props.request.headers.authorization.substring(\n      BEARER_PREFIX.length,\n    );\n\n    const verified = jwt.verify(token, MyGlobal.env.JWT_SECRET_KEY);\n\n    return verified;\n  } catch {\n    throw new UnauthorizedException(\"Invalid token\");\n  }\n}\n\nconst BEARER_PREFIX = \"Bearer \";\n```  \n\n### Provider Function Example  \n\n**\u26A0\uFE0F CRITICAL IMPORT PATHS:**\n- `jwtAuthorize` MUST be imported from `\"./jwtAuthorize\"` (same directory)\n- NOT `\"../../providers/authorize/jwtAuthorize\"` \u274C\n- NOT `\"../jwtAuthorize\"` \u274C\n- ONLY `\"./jwtAuthorize\"` \u2705\n\n```typescript\n// File path: src/providers/authorize/adminAuthorize.ts\nimport { ForbiddenException } from \"@nestjs/common\";\n\nimport { MyGlobal } from \"../../MyGlobal\";\nimport { jwtAuthorize } from \"./jwtAuthorize\";  // \u2190 CORRECT: Same directory import\nimport { AdminPayload } from \"../../decorators/payload/AdminPayload\";\n\nexport async function adminAuthorize(request: {\n  headers: {\n    authorization?: string;\n  };\n}): Promise<AdminPayload> {\n  const payload: AdminPayload = jwtAuthorize({ request }) as AdminPayload;\n\n  if (payload.type !== \"admin\") {\n    throw new ForbiddenException(`You're not ${payload.type}`);\n  }\n\n  const admin = await MyGlobal.prisma.admins.findFirst({\n    where: {\n      id: payload.id,\n      user: {\n        deleted_at: null,\n        is_banned: false,\n      },\n    },\n  });\n\n  if (admin === null) {\n    throw new ForbiddenException(\"You're not enrolled\");\n  }\n\n  return payload;\n}\n```  \n\n### Decorator Example\n\n```typescript\n// File path: src/decorators/AdminAuth.ts\nimport { SwaggerCustomizer } from \"@nestia/core\";\nimport { ExecutionContext, createParamDecorator } from \"@nestjs/common\";\nimport { Singleton } from \"tstl\";\n\nimport { adminAuthorize } from \"../providers/authorize/adminAuthorize\";\n\nexport const AdminAuth =\n  (): ParameterDecorator =>\n  (\n    target: object,\n    propertyKey: string | symbol | undefined,\n    parameterIndex: number,\n  ): void => {\n    SwaggerCustomizer((props) => {\n      props.route.security ??= [];\n      props.route.security.push({\n        bearer: [],\n      });\n    })(target, propertyKey as string, undefined!);\n    singleton.get()(target, propertyKey, parameterIndex);\n  };\n\nconst singleton = new Singleton(() =>\n  createParamDecorator(async (_0: unknown, ctx: ExecutionContext) => {\n    const request = ctx.switchToHttp().getRequest();\n    return adminAuthorize(request);\n  })(),\n);\n```  \n\n### Decorator Type Example  \n\nIn case of the columns related to Date type like `created_at`, `updated_at`, `deleted_at`, must use the `string & tags.Format<'date-time'>` Type instead of Date type.  \n\n```typescript\n// File path: src/decorators/payload/AdminPayload.ts\nimport { tags } from \"typia\";\n\nexport interface AdminPayload {\n  /**\n   * Admin ID.\n   */\n  id: string & tags.Format<\"uuid\">;\n\n  /**\n   * Discriminator for the discriminated union type.\n   */\n  type: \"admin\";\n}\n```  \n\n## Output Format  \n\nYou must provide your response in a structured JSON format containing the following nested structure:  \n\n**provider**: An object containing the authentication Provider function configuration  \n\n- **name**: The name of the authentication Provider function in `{Role.name(PascalCase)}Authorize` format (e.g., adminAuthorize, userAuthorize). This function verifies JWT tokens and returns user information for the specified role.  \n- **code**: Complete TypeScript code for the authentication Provider function only. Must include JWT verification, role checking, database query logic, and proper import statements for the Payload interface.\n\n**decorator**: An object containing the authentication Decorator configuration  \n\n- **name**: The name of the Decorator to be generated in `{Role.name(PascalCase)}Auth` format (e.g., AdminAuth, UserAuth). The decorator name used in Controller method parameters.  \n- **code**: Complete TypeScript code for the Decorator. Must include complete authentication decorator implementation using SwaggerCustomizer, createParamDecorator, and Singleton pattern.\n\n**decoratorType**: An object containing the Decorator Type configuration\n\n- **name**: The name of the Decorator Type in `{Role.name(PascalCase)}Payload` format (e.g., AdminPayload, UserPayload). Used as the TypeScript type for the authenticated user data.\n- **code**: Complete TypeScript code for the Payload type interface. Must include proper field definitions with typia tags for type safety.\n\n## Work Process  \n\n1. Analyze the input Role name  \n2. Generate Provider function for the Role  \n3. Define Payload interface  \n4. Implement Decorator  \n5. Verify that all code follows example patterns  \n6. Generate response in specified format  \n\n## Quality Standards  \n\n- Ensure type safety  \n- Follow NestJS conventions  \n- Complete error handling  \n- Code reusability  \n- Complete documentation  \n\n## Common Mistakes to Avoid\n\n1. **\u274C INCORRECT jwtAuthorize import paths:**\n   ```typescript\n   // WRONG - Do not use these:\n   import { jwtAuthorize } from \"../../providers/authorize/jwtAuthorize\";\n   import { jwtAuthorize } from \"../authorize/jwtAuthorize\";\n   import { jwtAuthorize } from \"../../providers/jwtAuthorize\";\n   ```\n\n2. **\u2705 CORRECT jwtAuthorize import path:**\n   ```typescript\n   // CORRECT - Always use this:\n   import { jwtAuthorize } from \"./jwtAuthorize\";\n   ```\n\nWhen users provide Role information, generate complete and practical authentication code according to the above rules." /* AutoBeSystemPromptConstant.REALIZE_AUTHORIZATION */,
+        },
+        {
+            id: (0, uuid_1.v4)(),
+            created_at: new Date().toISOString(),
+            type: "systemMessage",
+            text: [
+                "## Role",
+                "```json",
+                JSON.stringify(role),
+                "```",
+                "",
+                "## Prisma Schema",
+                "",
+                JSON.stringify((_a = ctx.state().prisma) === null || _a === void 0 ? void 0 : _a.schemas, null, 2),
+                "",
+                "## 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"),
+        },
+    ];
+};
+exports.transformRealizeAuthorizationHistories = transformRealizeAuthorizationHistories;
+//# sourceMappingURL=transformRealizeAuthorization.js.map

package/lib/agent/src/orchestrate/realize/histories/transformRealizeAuthorization.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformRealizeAuthorization.js","sourceRoot":"","sources":["../../../../../../src/orchestrate/realize/histories/transformRealizeAuthorization.ts"],"names":[],"mappings":";;;AAGA,+BAA0B;AAKnB,MAAM,sCAAsC,GAAG,CAGpD,GAAyB,EACzB,IAAuB,EAGvB,EAAE;;IACF,OAAO;QACL;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,eAAe;YACrB,IAAI,69UAAkD;SACvD;QACD;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,eAAe;YACrB,IAAI,EAAE;gBACJ,SAAS;gBACT,SAAS;gBACT,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;gBACpB,KAAK;gBACL,EAAE;gBACF,kBAAkB;gBAClB,EAAE;gBACF,IAAI,CAAC,SAAS,CAAC,MAAA,GAAG,CAAC,KAAK,EAAE,CAAC,MAAM,0CAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;gBACpD,EAAE;gBACF,gCAAgC;gBAChC,EAAE;gBACF,wEAAwE;gBACxE,EAAE;gBACF,oBAAoB,IAAI,CAAC,IAAI,mBAAmB,IAAI,CAAC,IAAI,YAAY;gBACrE,qBAAqB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,cAAc,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO;gBACtJ,mBAAmB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,iBAAiB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,UAAU;aAC3J,CAAC,IAAI,CAAC,IAAI,CAAC;SACb;KACF,CAAC;AACJ,CAAC,CAAC;AAvCW,QAAA,sCAAsC,0CAuCjD"}

package/lib/agent/src/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>;