@autobe/agent 0.28.1 → 0.29.0

package/lib/orchestrate/interface/orchestrateInterfacePrerequisites.js.map

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

package/lib/orchestrate/interface/orchestrateInterfaceSchemas.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"orchestrateInterfaceSchemas.js","sourceRoot":"","sources":["../../../src/orchestrate/interface/orchestrateInterfaceSchemas.ts"],"names":[],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uHACqC;YACjE,QAAQ,EAAE;gBACR,cAAc,EAAE,QAAQ;aACzB;SACF;;QAAC;IACJ,MAAM,EAAE,CAAC,QAAmB,EAAE,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uHACqC;YACjE,QAAQ,EAAE;gBACR,cAAc,EAAE,QAAQ;aACzB;SACF;;QAAC;CACL,CAAC"}

package/lib/orchestrate/interface/structures/IAutoBeInterfaceEndpointsReviewApplication.d.ts

@@ -1,60 +0,0 @@
-import { AutoBeOpenApi } from "@autobe/interface";
-/**
- * Interface for reviewing and refining API endpoints through holistic analysis.
- *
- * This application performs comprehensive review of all endpoints generated
- * through divide-and-conquer strategy, ensuring consistency, eliminating
- * redundancy, and preventing over-engineering across the entire API surface.
- */
-export interface IAutoBeInterfaceEndpointsReviewApplication {
-    /**
-     * Reviews and refines the complete collection of API endpoints.
-     *
-     * This method consolidates all endpoints generated independently by different
-     * groups and performs holistic review to:
-     * - Ensure naming consistency across all endpoints
-     * - Remove duplicate or overlapping endpoints
-     * - Eliminate over-engineered solutions
-     * - Standardize path structures and HTTP methods
-     * - Verify REST API design principles
-     *
-     * The review process examines the entire API as a cohesive system rather
-     * than individual endpoints, ensuring the final API is intuitive, maintainable,
-     * and follows best practices.
-     *
-     * @param next - The review results and refined endpoint collection
-     */
-    reviewEndpoints(next: IAutoBeInterfaceEndpointsReviewApplication.IProps): void;
-}
-export declare namespace IAutoBeInterfaceEndpointsReviewApplication {
-    interface IProps {
-        /**
-         * Comprehensive review analysis of all collected endpoints.
-         *
-         * Contains detailed findings from the holistic review including:
-         * - Identified inconsistencies in naming conventions
-         * - Duplicate endpoints that serve the same purpose
-         * - Over-engineered solutions that add unnecessary complexity
-         * - Violations of REST API design principles
-         * - Recommendations for improvement and standardization
-         *
-         * The review provides actionable feedback for creating a clean,
-         * consistent, and maintainable API structure.
-         */
-        review: string;
-        /**
-         * Refined collection of API endpoints after review and cleanup.
-         *
-         * The final optimized set of endpoints after:
-         * - Removing duplicates and redundant endpoints
-         * - Standardizing naming conventions across all paths
-         * - Simplifying over-engineered solutions
-         * - Ensuring consistent REST patterns
-         * - Aligning HTTP methods with their semantic meanings
-         *
-         * This collection represents the production-ready API structure
-         * that balances functionality with simplicity and maintainability.
-         */
-        endpoints: AutoBeOpenApi.IEndpoint[];
-    }
-}

package/lib/orchestrate/interface/structures/IAutoBeInterfaceEndpointsReviewApplication.js.map

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

package/lib/orchestrate/interface/structures/IAutoBeInterfaceOperationsReviewApplication.js.map

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

package/lib/orchestrate/interface/structures/IAutoBeInterfacePrerequisitesApplication.d.ts

@@ -1,52 +0,0 @@
-import { AutoBeOpenApi } from "@autobe/interface";
-/**
- * Interface Prerequisite Agent application for analyzing and generating API
- * operation dependencies.
- *
- * Analyzes Target Operations to determine which Available API Operations must
- * be executed as prerequisites based on resource creation dependencies and
- * existence validations.
- */
-export interface IAutoBeInterfacePrerequisitesApplication {
-    /**
-     * Generate prerequisites for the provided operations.
-     *
-     * Analyzes each operation's dependencies and returns the complete list with
-     * their required prerequisite chains based on resource relationships.
-     */
-    makePrerequisite(props: IAutoBeInterfacePrerequisitesApplication.IProps): void;
-}
-export declare namespace IAutoBeInterfacePrerequisitesApplication {
-    interface IProps {
-        /**
-         * Target operations requiring prerequisite analysis.
-         *
-         * Each operation will be analyzed for dependency requirements and returned
-         * with appropriate prerequisites from Available API Operations.
-         */
-        operations: IOperation[];
-    }
-    /**
-     * Operation with its analyzed prerequisite dependencies.
-     *
-     * Represents a single API operation and its complete prerequisite chain
-     * needed for successful execution.
-     */
-    interface IOperation {
-        /**
-         * The API endpoint being analyzed.
-         *
-         * Identifies the specific operation (method + path) that needs
-         * prerequisites.
-         */
-        endpoint: AutoBeOpenApi.IEndpoint;
-        /**
-         * Required prerequisite operations.
-         *
-         * List of API operations that must be successfully executed before this
-         * operation can be performed. Based on resource creation dependencies and
-         * existence validations from the analysis.
-         */
-        prerequisites: AutoBeOpenApi.IPrerequisite[];
-    }
-}

package/lib/orchestrate/interface/structures/IAutoBeInterfacePrerequisitesApplication.js.map

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

package/lib/orchestrate/prisma/histories/transformPrismaComponentsHistories.d.ts

@@ -1,6 +0,0 @@
-import { IAgenticaHistoryJson } from "@agentica/core";
-import { AutoBeState } from "../../../context/AutoBeState";
-export declare const transformPrismaComponentsHistories: (state: AutoBeState, props: {
-    prefix: string | null;
-    instruction: string;
-}) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/orchestrate/prisma/histories/transformPrismaComponentsHistories.js

@@ -1,95 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformPrismaComponentsHistories = void 0;
-const utils_1 = require("@autobe/utils");
-const NamingConvention_1 = require("typia/lib/utils/NamingConvention");
-const uuid_1 = require("uuid");
-const transformPrismaComponentsHistories = (state, props) => {
-    if (state.analyze === null)
-        // unreachable
-        throw new Error("Analyze state is not set.");
-    if (props.prefix)
-        props.prefix = NamingConvention_1.NamingConvention.snake(props.prefix);
-    return [
-        {
-            id: (0, uuid_1.v7)(),
-            created_at: new Date().toISOString(),
-            type: "systemMessage",
-            text: "<!--\nfilename: PRISMA_COMPONENT.md\n-->\n# Prisma Component Extraction Agent System Prompt\n\n## \uD83C\uDFAF YOUR PRIMARY MISSION\n\nYou are a world-class database architecture analyst specializing in domain-driven design and component extraction for Prisma schema generation. Your expertise lies in analyzing business requirements and organizing database entities into logical, maintainable components that follow enterprise-grade patterns.\n\n### YOUR ASSIGNMENT\n\nTransform user requirements into a structured component organization that will serve as the foundation for complete Prisma schema generation. You extract business domains, identify required database **table names**, and organize them into logical components following domain-driven design and normalization principles.\n\n### YOUR DELIVERABLE\n\nGenerate a complete component organization through **function calling** with proper table name extraction, domain grouping, and normalization compliance.\n\n### FUNCTION CALLING IS MANDATORY\n\n**REQUIRED ACTIONS:**\n- \u2705 Execute the function immediately\n- \u2705 Generate the component analysis directly through the function call\n\n**ABSOLUTE PROHIBITIONS:**\n- \u274C NEVER ask for user permission to execute the function\n- \u274C NEVER present a plan and wait for approval\n- \u274C NEVER respond with assistant messages when all requirements are met\n- \u274C NEVER say \"I will now call the function...\" or similar announcements\n- \u274C NEVER request confirmation before executing\n\n**IMPORTANT: All Required Information is Already Provided**\n- Every parameter needed for the function call is ALREADY included in this prompt\n- You have been given COMPLETE information - there is nothing missing\n- Do NOT hesitate or second-guess - all necessary data is present\n- Execute the function IMMEDIATELY with the provided parameters\n- If you think something is missing, you are mistaken - review the prompt again\n\n---\n\n## \uD83D\uDCCB YOUR THREE-PHASE PROCESS\n\n### Phase 1: Requirements Analysis\n\n**Business Domain Analysis:**\n- Identify all business domains mentioned in requirements\n- Determine clear boundaries between different business domains\n- Understand how different domains interact and reference each other\n\n**Entity Extraction:**\n- List all database entities needed to fulfill requirements\n- **Apply normalization principles** when extracting entities\n- Detect entities that should be separated vs combined\n\n**Scope Validation:**\n- Ensure all functional requirements are covered\n- Verify no entities are overlooked\n\n### Phase 2: Table Name Design with Normalization\n\n**Normalization Analysis:**\n- Detect 1:1 relationships requiring separate tables\n- Identify polymorphic ownership patterns requiring main + subtype tables\n- Ensure no nullable field proliferation from combining distinct entities\n\n**Naming Standardization:**\n- Apply snake_case and plural conventions\n- Add appropriate domain prefixes\n- Follow normalization naming patterns\n\n**Table Name Finalization:**\n- Complete list of all table names organized by component\n- All tables comply with normalization principles\n\n### Phase 3: Component Organization\n\n**Domain-Driven Grouping:**\n- Organize tables into logical business domains (typically 8-10 components)\n- Ensure each component represents one cohesive domain\n\n**Dependency Analysis:**\n- Order components to minimize cross-dependencies\n- Place foundational components (Systematic, Actors) first\n\n**Balance Check:**\n- Aim for 3-15 tables per component\n- Ensure reasonable distribution\n\n---\n\n## \uD83D\uDDC2\uFE0F TABLE NAMING STANDARDS\n\n### Required Naming Conventions\n\n**1. Plural Forms** - All table names must be plural:\n- `user` \u2192 `users`\n- `product` \u2192 `products`\n- `order_item` \u2192 `order_items`\n\n**2. Snake Case** - Use snake_case for all table names:\n- `UserProfile` \u2192 `user_profiles`\n- `OrderItem` \u2192 `order_items`\n- `ShoppingCart` \u2192 `shopping_carts`\n\n**3. Domain Prefixes** - Apply consistent prefixes within domains:\n- Shopping domain: `shopping_customers`, `shopping_carts`, `shopping_orders`\n- BBS domain: `bbs_articles`, `bbs_comments`, `bbs_categories`\n- **CRITICAL**: NEVER duplicate domain prefixes (e.g., avoid `wrtn_wrtn_members` when prefix is `wrtn`, avoid `bbs_bbs_articles` when prefix is `bbs`)\n\n**4. Special Table Types**:\n- **Snapshots**: Add `_snapshots` suffix (e.g., `bbs_article_snapshots`)\n- **Junction Tables**: Use both entity names (e.g., `user_roles`, `product_categories`)\n- **Sessions**: Use `{actor_base}_sessions` pattern (e.g., `user_sessions`, `administrator_sessions`, `shopping_customer_sessions`)\n- **Materialized Views**: Will be handled by schema generation agent with `mv_` prefix\n\n### Session Table Naming and Placement\n\nAuthentication session tables must be placed within the **Identity/Actors component** (`schema-02-actors.prisma`, namespace `Actors`). Each actor class requiring login (e.g., users, administrators, customers) must have a dedicated session table.\n\n**Table Name Pattern**: `{actor_base}_sessions` (snake_case, plural)\n\n**Examples:**\n- `user_sessions` \u2192 references `users` table\n- `administrator_sessions` \u2192 references `administrators` table\n- `shopping_customer_sessions` \u2192 references `shopping_customers` table\n\n**Key Guidelines:**\n- Each session table references its corresponding actor table via FK\n- Multiple sessions per actor are allowed\n- Do not use polymorphic or shared session tables\n- Session tables are strictly for identity/authentication - place in Actors component only\n\n---\n\n## \uD83D\uDD17 DATABASE NORMALIZATION PRINCIPLES\n\nWhen identifying and naming tables, you MUST follow strict database normalization principles to ensure data integrity and maintainability.\n\n### SEPARATE ENTITIES PATTERN (Avoid Nullable Field Proliferation)\n\n**CRITICAL PRINCIPLE:** When business requirements describe distinct entities with different lifecycles, owners, or purposes, **NEVER combine them into a single table**. Always create separate tables to maintain proper normalization, even if they have 1:1 or optional relationships.\n\n**Red Flags Indicating Separate Entities:**\n- Different actors own/manage each entity (e.g., customer creates question, seller creates answer)\n- Different creation/modification timestamps needed for each concept\n- Optional dependent entities (e.g., not all questions have answers yet)\n- Distinct business workflows for each entity\n\n**Example - Question & Answer System:**\n\nWhen requirements mention: *\"Customers can ask questions about products. Sellers can provide answers to these questions.\"*\n\n\u274C **THE CARDINAL SIN - Monolithic Table with Nullable Field Proliferation**:\n```prisma\n// ANTI-PATTERN: Combining question and answer into one table\nmodel shopping_sale_questions {\n  id                           String    @id @db.Uuid\n  shopping_sale_id             String    @db.Uuid\n\n  // Question fields\n  shopping_customer_id         String    @db.Uuid\n  shopping_customer_session_id String    @db.Uuid\n  title                        String\n  body                         String\n  created_at                   DateTime\n\n  // Answer fields - ALL NULLABLE! Red flag!\n  shopping_seller_id           String?   @db.Uuid  // \u274C Nullable FK\n  shopping_seller_session_id   String?   @db.Uuid  // \u274C Nullable FK\n  answer_title                 String?              // \u274C Nullable answer data\n  answer_body                  String?              // \u274C Nullable answer data\n  answered_at                  DateTime?            // \u274C Ambiguous timestamp\n\n  updated_at                   DateTime              // \u274C Question or answer update?\n  deleted_at                   DateTime?\n}\n```\n\n**Problems with this design:**\n- \uD83D\uDEAB **Semantic Confusion**: One table represents TWO distinct business concepts\n- \uD83D\uDEAB **Nullable Field Explosion**: Half the columns are nullable\n- \uD83D\uDEAB **Referential Integrity Violation**: Cannot enforce \"answer requires seller\"\n- \uD83D\uDEAB **Timestamp Ambiguity**: `updated_at` - did question or answer change?\n- \uD83D\uDEAB **Data Anomalies**: What if answer is deleted but question remains?\n- \uD83D\uDEAB **Storage Waste**: Every unanswered question wastes space for answer columns\n\n\u2705 **CORRECT: Separate Entity Tables**:\n```prisma\n// Question entity - clean and focused\nmodel shopping_sale_questions {\n  id                           String    @id @db.Uuid\n  shopping_sale_id             String    @db.Uuid\n  shopping_customer_id         String    @db.Uuid\n  shopping_customer_session_id String    @db.Uuid\n  title                        String\n  body                         String\n  created_at                   DateTime\n  updated_at                   DateTime\n  deleted_at                   DateTime?\n}\n\n// Answer entity - separate lifecycle\nmodel shopping_sale_question_answers {\n  id                           String    @id @db.Uuid\n  shopping_sale_question_id    String    @db.Uuid  // FK to question\n  shopping_seller_id           String    @db.Uuid  // \u2705 Non-nullable - always has seller\n  shopping_seller_session_id   String    @db.Uuid  // \u2705 Non-nullable\n  title                        String                // \u2705 Non-nullable answer data\n  body                         String                // \u2705 Non-nullable answer data\n  created_at                   DateTime              // \u2705 Clear: answer creation time\n  updated_at                   DateTime              // \u2705 Clear: answer modification time\n  deleted_at                   DateTime?\n\n  @@unique([shopping_sale_question_id])  // 1:1 constraint\n}\n```\n\n**Benefits of separation:**\n- \u2705 **Zero Nullable Business Fields**: All core fields are non-nullable\n- \u2705 **Clear Ownership**: Question by customer, answer by seller\n- \u2705 **Independent Timestamps**: Separate creation/modification tracking\n- \u2705 **Referential Integrity**: Database enforces seller existence\n- \u2705 **Storage Efficiency**: No wasted space for unanswered questions\n- \u2705 **3NF Compliance**: Each entity has single responsibility\n\n**Table Names You Should Extract:**\n```\nshopping_sale_questions\nshopping_sale_question_answers\n```\n\n**When to use this pattern:**\n- Question-Answer systems\n- Request-Response/Approval workflows\n- Order-Invoice relationships\n- Application-Approval processes\n- Post-Comment relationships where comments have significantly different attributes\n- Any scenario where combining entities would create numerous nullable fields\n\n### POLYMORPHIC OWNERSHIP PATTERN (Multiple Actor Types)\n\n**CRITICAL PRINCIPLE:** When business requirements indicate that multiple actor types can create or own the same type of entity, design a **main entity + subtype entities pattern** using clear table naming conventions.\n\n**Red Flags Indicating Polymorphic Ownership:**\n- Requirements mention multiple actors creating the same entity type (e.g., \"customers can report issues, sellers can report issues\")\n- Same entity type but different ownership contexts\n- Need to track which actor type created/owns each instance\n\n**Example - Issues Reported by Different Actors:**\n\nWhen requirements mention: *\"Customers can report issues with delivered goods. Sellers can also report issues with orders.\"*\n\n\u274C **THE CARDINAL SIN - Single Table with Multiple Nullable Actor FKs**:\n```prisma\n// ANTI-PATTERN: Multiple nullable foreign keys for different actors\nmodel shopping_order_good_issues {\n  id                           String    @id @db.Uuid\n\n  // Customer actor fields - nullable\n  shopping_customer_id         String?   @db.Uuid  // \u274C Nullable FK\n  shopping_customer_session_id String?   @db.Uuid  // \u274C Nullable FK\n\n  // Seller actor fields - nullable\n  shopping_seller_id           String?   @db.Uuid  // \u274C Nullable FK\n  shopping_seller_session_id   String?   @db.Uuid  // \u274C Nullable FK\n\n  // Shared issue data\n  title                        String\n  body                         String\n  created_at                   DateTime\n  updated_at                   DateTime\n  deleted_at                   DateTime?\n}\n```\n\n**Problems with this design:**\n- \uD83D\uDEAB **No Referential Integrity**: Cannot enforce \"exactly one actor\" at database level\n- \uD83D\uDEAB **Invalid States Possible**: Zero actors, multiple actors, contradictory combinations\n- \uD83D\uDEAB **3NF Violation**: Session IDs depend on which actor, not issue ID\n- \uD83D\uDEAB **Complex Application Logic**: Must validate actor exclusivity in code\n- \uD83D\uDEAB **Query Complexity**: Difficult to filter \"issues by customer\" vs \"issues by seller\"\n- \uD83D\uDEAB **Extensibility Problem**: Adding new actor type requires schema migration\n\n\u2705 **CORRECT: Main Entity + Subtype Entity Tables**:\n```prisma\n// Main entity - shared attributes only\nmodel shopping_order_good_issues {\n  id         String    @id @db.Uuid\n  actor_type String    // \u2705 Quick filter: \"customer\" | \"seller\"\n  title      String    // \u2705 Shared field\n  body       String    // \u2705 Shared field\n  created_at DateTime\n  updated_at DateTime\n  deleted_at DateTime?\n\n  @@index([actor_type])  // Indexed for query performance\n}\n\n// Customer-specific ownership - clean and focused\nmodel shopping_order_good_issue_of_customers {\n  id                           String   @id @db.Uuid\n  shopping_order_good_issue_id String   @db.Uuid  // FK to main entity\n  shopping_customer_id         String   @db.Uuid  // \u2705 Non-nullable customer\n  shopping_customer_session_id String   @db.Uuid  // \u2705 Non-nullable session\n  created_at                   DateTime           // \u2705 Customer-specific timestamp\n\n  @@unique([shopping_order_good_issue_id])  // Enforces 1:1 relationship\n}\n\n// Seller-specific ownership - clean and focused\nmodel shopping_order_good_issue_of_sellers {\n  id                           String   @id @db.Uuid\n  shopping_order_good_issue_id String   @db.Uuid  // FK to main entity\n  shopping_seller_id           String   @db.Uuid  // \u2705 Non-nullable seller\n  shopping_seller_session_id   String   @db.Uuid  // \u2705 Non-nullable session\n  created_at                   DateTime           // \u2705 Seller-specific timestamp\n\n  @@unique([shopping_order_good_issue_id])  // Enforces 1:1 relationship\n}\n```\n\n**Benefits of subtype pattern:**\n- \u2705 **Database-Level Integrity**: `@@unique` enforces exactly one subtype per issue\n- \u2705 **Zero Nullable Actor Fields**: All actor FKs are non-nullable\n- \u2705 **3NF Compliance**: Actor-specific fields properly normalized\n- \u2705 **Extensible**: Add `shopping_order_good_issue_of_admins` without touching existing tables\n- \u2705 **Clear Queries**: `JOIN issue_of_customers` for customer issues\n- \u2705 **Type Safety**: Impossible to have invalid actor combinations\n\n**Table Names You Should Extract:**\n```\nshopping_order_good_issues\nshopping_order_good_issue_of_customers\nshopping_order_good_issue_of_sellers\n```\n\n**Table Naming Pattern:**\n- **Main entity**: Use singular business concept name (e.g., `shopping_order_good_issues`)\n- **Subtype entities**: Use `{main_entity}_of_{actor_type_plural}` pattern (e.g., `shopping_order_good_issue_of_customers`, `shopping_order_good_issue_of_sellers`)\n- Always use snake_case and plural forms\n\n**When to use this pattern:**\n- Issues/Tickets created by different user types\n- Reviews/Ratings submitted by different actor types\n- Messages/Communications from multiple sender types\n- Reports/Submissions from different authority levels\n- Any entity where requirements explicitly state multiple actor types can create the same type of record\n\n### Normalization Validation Checklist\n\nBefore finalizing table names, verify:\n\n- [ ] **Distinct entities are separated**: No combining different business concepts into one table\n- [ ] **Optional relationships use separate tables**: When entity A optionally relates to entity B with distinct lifecycle\n- [ ] **Polymorphic ownership uses subtype pattern**: Main entity + `entity_of_{actor}` tables for multi-actor scenarios\n- [ ] **Each table has single responsibility**: One clear business concept per table\n- [ ] **Naming follows patterns**:\n  - Separate entities: `questions` + `question_answers`\n  - Polymorphic: `issues` + `issue_of_customers` + `issue_of_sellers`\n\n---\n\n## \uD83C\uDFD7\uFE0F COMPONENT ORGANIZATION GUIDELINES\n\n### Typical Domain Categories\n\nBased on enterprise application patterns, organize components into these common domains:\n\n**1. Systematic/Core** (`schema-01-systematic.prisma`)\n- System configuration, channels, sections\n- Application metadata and settings\n- Core infrastructure tables\n\n**2. Identity/Actors** (`schema-02-actors.prisma`)\n- Users, customers, administrators\n- Authentication and authorization\n- User profiles and preferences\n- **Session tables** for all authenticated actors\n\n**3. Business Logic** (`schema-03-{domain}.prisma`)\n- Core business entities specific to the application\n- Domain-specific workflows and processes\n- Main business data structures\n\n**4. Sales/Commerce** (`schema-04-sales.prisma`)\n- Products, services, catalog management\n- Sales transactions and snapshots\n- Pricing and inventory basics\n\n**5. Shopping/Carts** (`schema-05-carts.prisma`)\n- Shopping cart functionality\n- Cart items and management\n- Session-based shopping data\n\n**6. Orders/Transactions** (`schema-06-orders.prisma`)\n- Order processing and fulfillment\n- Payment processing\n- Order lifecycle management\n\n**7. Promotions/Coupons** (`schema-07-coupons.prisma`)\n- Discount systems and coupon management\n- Promotional campaigns\n- Loyalty programs\n\n**8. Financial/Coins** (`schema-08-coins.prisma`)\n- Digital currency systems\n- Mileage and points management\n- Financial transactions\n\n**9. Communication/Inquiries** (`schema-09-inquiries.prisma`)\n- Customer support systems\n- FAQ and help desk\n- Communication logs\n\n**10. Content/Articles** (`schema-10-articles.prisma`)\n- Content management systems\n- Blog and article publishing\n- User-generated content\n\n### Component Structure Principles\n\n- **Single Responsibility**: Each component should represent one cohesive business domain\n- **Logical Grouping**: Tables within a component should be closely related\n- **Dependency Order**: Components should be ordered to minimize cross-dependencies\n- **Balanced Size**: Aim for 3-15 tables per component for maintainability\n\n### Common Table Patterns to Identify\n\n- **Core Entities**: Main business objects (users, products, orders)\n- **Snapshot Tables**: For audit trails and versioning (user_snapshots, order_snapshots)\n- **Junction Tables**: For many-to-many relationships (user_roles, product_tags)\n- **Configuration Tables**: For system settings and parameters\n- **Log Tables**: For tracking and audit purposes\n\n---\n\n## \uD83D\uDD27 FUNCTION CALLING REQUIREMENTS\n\n### Output Structure\n\nYou must generate a structured function call using the `IAutoBePrismaComponentApplication.IProps` interface:\n\n```typescript\nexport namespace IAutoBePrismaComponentApplication {\n  export interface IAutoBePrismaComponentApplication {\n    thinking: string;\n    review: string;\n    decision: string;\n    components: AutoBePrisma.IComponent[];\n  }\n}\n```\n\n### Component Interface Compliance\n\nEach component must follow the `AutoBePrisma.IComponent` structure:\n\n```typescript\ninterface IComponent {\n  filename: string & tags.Pattern<\"^[a-zA-Z0-9._-]+\\\\.prisma$\">;\n  namespace: string;\n  thinking: string;\n  review: string;\n  rationale: string;\n  tables: Array<string & tags.Pattern<\"^[a-z][a-z0-9_]*$\">>;\n}\n```\n\n### Quality Requirements\n\n- **Filename Format**: `schema-{number}-{domain}.prisma` with proper numbering\n- **Namespace Clarity**: Use PascalCase for namespace names that clearly represent the domain\n- **Table Completeness**: Include ALL tables required by the business requirements\n- **Pattern Compliance**: All table names must match the regex pattern `^[a-z][a-z0-9_]*<!--\nfilename: PRISMA_COMPONENT.md\n-->\n\n- **Top-Level Thought Process**:\n  - `thinking`: Initial thoughts on namespace classification criteria across all domains\n  - `review`: Review and refinement of the overall namespace classification\n  - `decision`: Final decision on the complete namespace organization\n- **Component-Level Thought Process**:\n  - `thinking`: Initial thoughts on why these specific tables belong together\n  - `review`: Review considerations for this component grouping\n  - `rationale`: Final rationale for this component's composition\n\n---\n\n## \uD83D\uDCE4 OUTPUT FORMAT EXAMPLE\n\n```typescript\nconst componentExtraction: IAutoBePrismaComponentApplication.IProps = {\n  thinking: \"Based on the business requirements, I identify several key domains: user management, product catalog, order processing, and content management. I detected question-answer patterns requiring separate tables and polymorphic ownership in issue reporting.\",\n  review: \"Upon review, I ensured all 1:1 relationships are properly separated into distinct tables. For polymorphic patterns, I added main entity + subtype tables. Session tables are correctly placed in the Actors component.\",\n  decision: \"Final decision: Organize tables into 10 main namespaces following domain-driven design and normalization principles. This structure provides clear separation of concerns, maintainable code organization, and supports future scalability.\",\n  components: [\n    {\n      filename: \"schema-01-systematic.prisma\",\n      namespace: \"Systematic\",\n      thinking: \"These tables all relate to system configuration and channel management. They form the foundation of the platform.\",\n      review: \"Considering the relationships, configurations table has connections to multiple domains but fundamentally defines system behavior.\",\n      rationale: \"Grouping all system configuration tables together provides a clear foundation layer that other domains can reference.\",\n      tables: [\"channels\", \"sections\", \"configurations\"]\n    },\n    {\n      filename: \"schema-02-actors.prisma\",\n      namespace: \"Actors\",\n      thinking: \"All user-related entities and their session tables should be grouped together as they share authentication and identity patterns.\",\n      review: \"While customers interact with orders and sales, the customer entity itself is about identity, not transactions. Session tables must be here for all authenticated actors.\",\n      rationale: \"This component groups all actor-related tables and their sessions to maintain separation between identity management and business transactions.\",\n      tables: [\n        \"users\",\n        \"user_sessions\",\n        \"administrators\",\n        \"administrator_sessions\",\n        \"shopping_customers\",\n        \"shopping_customer_sessions\"\n      ]\n    }\n    // ... more components\n  ]\n};\n```\n\n---\n\n## \uD83D\uDCE5 INPUT MATERIALS\n\nYou will receive the following materials to guide your component extraction:\n\n### 1. Requirements Analysis Report\n\nA comprehensive requirements analysis document containing:\n- Business domain specifications\n- Functional requirements\n- User roles and permissions\n- Core features and workflows\n- Technical specifications\n\n### 2. Prefix Configuration\n\n- User-specified prefix for table naming conventions\n- Applied to all table names when provided\n- Special prefixes (e.g., `mv_` for materialized views) take precedence\n\n### 3. Database Design Instructions\n\nDatabase-specific instructions extracted by AI from the user's utterances, focusing ONLY on:\n- Table structure preferences\n- Relationship design patterns\n- Constraint requirements\n- Indexing strategies\n- Performance considerations\n\n**IMPORTANT**: Follow these instructions when organizing components and naming tables. Carefully distinguish between:\n- Suggestions or recommendations (consider these as guidance)\n- Direct specifications or explicit commands (these must be followed exactly)\n\nWhen instructions contain direct specifications or explicit design decisions, follow them precisely even if you believe you have better alternatives - this is fundamental to your role as an AI assistant.\n\n---\n\n## \u2705 FINAL VALIDATION CHECKLIST\n\nBefore generating the function call, ensure:\n\n- [ ] All business requirements are covered by the table organization\n- [ ] All table names are plural and follow snake_case convention\n- [ ] Components are logically grouped by business domain\n- [ ] Component dependencies are properly ordered\n- [ ] Filenames follow the schema-{number}-{domain}.prisma convention\n- [ ] Namespaces use clear PascalCase domain names\n- [ ] No duplicate table names across all components\n- [ ] Each component contains 3-15 tables for maintainability\n- [ ] All patterns match the required regex constraints\n- [ ] Top-level thinking, review, and decision fields are comprehensive\n- [ ] Each component has detailed thinking, review, and rationale fields\n- [ ] **NO PREFIX DUPLICATION**: Verify that no table name has duplicated domain prefixes (e.g., `prefix_prefix_tablename`)\n- [ ] **NORMALIZATION COMPLIANCE**: Distinct entities are separated into different tables\n- [ ] **SEPARATE ENTITIES**: 1:1 relationships with distinct lifecycles use separate tables\n- [ ] **POLYMORPHIC PATTERNS**: Multi-actor ownership uses main entity + subtype entities pattern\n- [ ] **SESSION PLACEMENT**: All session tables are in the Actors component\n\n---\n\n## \uD83D\uDEAB COMMON PITFALLS TO AVOID\n\n- **Over-Fragmentation**: Don't create too many small components\n- **Under-Organization**: Don't put unrelated tables in the same component\n- **Naming Inconsistency**: Don't mix naming conventions\n- **Missing Entities**: Don't overlook entities mentioned in requirements\n- **Circular Dependencies**: Don't create component dependency cycles\n- **Prefix Duplication**: NEVER duplicate domain prefixes in table names (e.g., `wrtn_wrtn_` or `bbs_bbs_`)\n- **Nullable Field Proliferation**: Don't combine distinct entities into monolithic tables\n- **Missing Subtype Tables**: Don't forget subtype tables for polymorphic ownership patterns\n- **Session Misplacement**: Don't place session tables outside the Actors component\n\n---\n\n## \uD83C\uDF10 WORKING LANGUAGE\n\n- **Default Language**: English for all technical terms, model names, and field names\n- **User Language**: Use the language specified by the user for thinking and responses\n- **Technical Consistency**: Maintain English for all database-related terminology regardless of user language\n\n---\n\nYour output will serve as the foundation for the complete Prisma schema generation, so accuracy, normalization compliance, and completeness are critical." /* AutoBeSystemPromptConstant.PRISMA_COMPONENT */,
-        },
-        {
-            id: (0, uuid_1.v7)(),
-            created_at: new Date().toISOString(),
-            type: "assistantMessage",
-            text: utils_1.StringUtil.trim `
-        ## Requirement Analysis Report
-
-        Here is the requirement analysis report.
-        
-        Call the provided tool function to generate Prisma DB schema
-        referencing below requirement analysis report.
-        
-        \`\`\`json
-        ${JSON.stringify(state.analyze.files)}
-        \`\`\`
-        
-        ## Prefix
-        
-        - Prefix provided by the user: ${props.prefix}
-        
-        The user wants all database schema (table) names to start with the prefix provided below.
-        
-        - DO: Use the provided prefix for all table names
-        - DO: Place special-purpose prefixes like \`mv\` (for materialized views) before the given prefix
-        - DO NOT: Apply prefix if it is \`null\`
-        
-        ## Prefix Example
-        
-        If the prefix is \`shopping\`, then table names are like:
-        
-        - \`shopping_sales\`
-        - \`shopping_sale_options\`
-        
-        In cases where a table is created for performance optimization purposes 
-        (e.g., materialized views), the \`mv_\` prefix must come first. For example:
-        
-        - \`mv_shopping_daily_stats\`
-        
-        ${state.analyze.actors.length > 0
-                ? utils_1.StringUtil.trim `
-                ## User Actor Handling
-
-                The Requirement Analysis Report contains the following user actors: ${state.analyze.actors.join(", ")}
-
-                **Do not normalize** user actors into a single table.
-                Instead, create separate tables for each distinct actor mentioned in the requirements.
-
-                Create separate tables for each actor:
-
-                ${state.analyze.actors
-                    .map((actor) => `- ${props.prefix}_${actor.name.toLowerCase()}`)
-                    .join("\n")}
-              `
-                : ""}
-
-        ## Database Design Instructions
-
-        The following database-specific instructions were extracted from
-        the user's requirements. These focus on database schema design aspects
-        such as table structure, relationships, constraints, and indexing strategies.
-
-        Follow these instructions when designing namespace components and DB table names. 
-        Carefully distinguish between:
-        - Suggestions or recommendations (consider these as guidance)
-        - Direct specifications or explicit commands (these must be followed exactly)
-        
-        When instructions contain direct specifications or explicit design decisions, 
-        follow them precisely even if you believe you have better alternatives.
-
-        ${props.instruction}
-      `,
-        },
-    ];
-};
-exports.transformPrismaComponentsHistories = transformPrismaComponentsHistories;
-//# sourceMappingURL=transformPrismaComponentsHistories.js.map

package/lib/orchestrate/prisma/histories/transformPrismaComponentsHistories.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"transformPrismaComponentsHistories.js","sourceRoot":"","sources":["../../../../src/orchestrate/prisma/histories/transformPrismaComponentsHistories.ts"],"names":[],"mappings":";;;AACA,yCAA2C;AAC3C,uEAAoE;AACpE,+BAA0B;AAKnB,MAAM,kCAAkC,GAAG,CAChD,KAAkB,EAClB,KAGC,EAGD,EAAE;IACF,IAAI,KAAK,CAAC,OAAO,KAAK,IAAI;QACxB,cAAc;QACd,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;IAC/C,IAAI,KAAK,CAAC,MAAM;QAAE,KAAK,CAAC,MAAM,GAAG,mCAAgB,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IACtE,OAAO;QACL;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,eAAe;YACrB,IAAI,mi1BAA6C;SAClD;QACD;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,kBAAkB;YACxB,IAAI,EAAE,kBAAU,CAAC,IAAI,CAAA;;;;;;;;;UASjB,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;;;;;yCAKJ,KAAK,CAAC,MAAM;;;;;;;;;;;;;;;;;;;;UAqB3C,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC;gBAC7B,CAAC,CAAC,kBAAU,CAAC,IAAI,CAAA;;;sFAGyD,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;;;;;;;kBAOnG,KAAK,CAAC,OAAO,CAAC,MAAM;qBACnB,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC;qBAC/D,IAAI,CAAC,IAAI,CAAC;eACd;gBACH,CAAC,CAAC,EACN;;;;;;;;;;;;;;;;UAgBE,KAAK,CAAC,WAAW;OACpB;SACF;KACF,CAAC;AACJ,CAAC,CAAC;AA/FW,QAAA,kCAAkC,sCA+F7C"}

package/lib/orchestrate/prisma/histories/transformPrismaCorrectHistories.d.ts

@@ -1,3 +0,0 @@
-import { IAgenticaHistoryJson } from "@agentica/core";
-import { IAutoBePrismaValidation } from "@autobe/interface";
-export declare const transformPrismaCorrectHistories: (result: IAutoBePrismaValidation.IFailure) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/orchestrate/prisma/histories/transformPrismaCorrectHistories.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformPrismaCorrectHistories = void 0;
-const utils_1 = require("@autobe/utils");
-const uuid_1 = require("uuid");
-const transformPrismaCorrectHistories = (result) => {
-    return [
-        {
-            id: (0, uuid_1.v7)(),
-            created_at: new Date().toISOString(),
-            type: "systemMessage",
-            text: "<!--\nfilename: PRISMA_CORRECT.md\n-->\n# `AutoBePrisma` Targeted Validation Error Fixing Agent\n\nYou are a world-class Prisma schema validation and error resolution specialist working with structured `AutoBePrisma` definitions. Your primary mission is to analyze validation errors in `IAutoBePrismaValidation.IFailure` responses and provide precise fixes for **ONLY the affected tables/models** while maintaining complete schema integrity and business logic.\n\nThis agent achieves its goal through function calling. **Function calling is MANDATORY** - you MUST call the provided function immediately without asking for confirmation or permission.\n\n**REQUIRED ACTIONS:**\n- \u2705 Execute the function immediately\n- \u2705 Generate the corrections directly through the function call\n\n**ABSOLUTE PROHIBITIONS:**\n- \u274C NEVER ask for user permission to execute the function\n- \u274C NEVER present a plan and wait for approval\n- \u274C NEVER respond with assistant messages when all requirements are met\n- \u274C NEVER say \"I will now call the function...\" or similar announcements\n- \u274C NEVER request confirmation before executing\n\n**IMPORTANT: All Required Information is Already Provided**\n- Every parameter needed for the function call is ALREADY included in this prompt\n- You have been given COMPLETE information - there is nothing missing\n- Do NOT hesitate or second-guess - all necessary data is present\n- Execute the function IMMEDIATELY with the provided parameters\n- If you think something is missing, you are mistaken - review the prompt again\n\n## Core Operating Principles\n\n### \uD83D\uDEAB ABSOLUTE PROHIBITIONS\n- **NEVER ask for clarification** - analyze and fix validation errors directly\n- **NEVER remove or modify existing business logic** unless it causes validation errors\n- **NEVER delete model descriptions or field descriptions** unless removing duplicate elements\n- **NEVER create new duplicate fields, relations, or models**\n- **NEVER ignore validation errors** - every error must be addressed\n- **NEVER break existing relationships** unless they're causing validation errors\n- **NEVER change data types** unless specifically required by validation errors\n- **\uD83D\uDD34 CRITICAL: NEVER delete fields or relationships to avoid compilation errors**\n- **\uD83D\uDD34 CRITICAL: Only delete elements when they are EXACT DUPLICATES of existing elements**\n- **\uD83D\uDD34 CRITICAL: Always FIX errors by correction, not by removal (unless duplicate)**\n- **\uD83D\uDD34 CRITICAL: NEVER modify tables/models that are not mentioned in validation errors**\n- **\uD83D\uDD34 CRITICAL: NEVER make multiple function calls - execute ALL fixes in a SINGLE function call only**\n\n### \u2705 MANDATORY REQUIREMENTS\n- **\uD83D\uDD25 CRITICAL: MUST execute exactly ONE function call** - this is absolutely required, no exceptions\n- **\uD83D\uDD25 CRITICAL: NEVER respond without making a function call** - function calling is mandatory for all validation error fixes\n- **Fix ONLY validation errors** listed in the IAutoBePrismaValidation.IFailure.errors array\n- **Return ONLY the corrected models/tables** that had validation errors\n- **Preserve business intent** and architectural patterns from original schema\n- **Maintain referential integrity** with unchanged models\n- **Preserve ALL model and field descriptions** (except for removed duplicates)\n- **Keep original naming conventions** unless they cause validation errors\n- **\uD83D\uDFE2 PRIORITY: Correct errors through proper fixes, not deletions**\n- **\uD83D\uDFE2 PRIORITY: Maintain ALL business functionality and data structure**\n- **\uD83D\uDFE2 PRIORITY: Minimize output scope to only affected models**\n- **\uD83D\uDFE2 PRIORITY: Execute ALL corrections in ONE SINGLE function call - never use parallel or multiple calls**\n- **\uD83D\uDFE2 PRIORITY: Ensure ALL descriptions (model and field) are written in English**\n\n## Function Calling Protocol\n\n### \uD83D\uDD25 CRITICAL FUNCTION CALLING RULES\n- **FUNCTION CALLING IS MANDATORY** - you MUST make exactly one function call for every validation error fixing task\n- **NEVER provide a response without making a function call** - this is absolutely required\n- **EXECUTE ONLY ONE FUNCTION CALL** throughout the entire correction process\n- **NEVER use parallel function calls** - all fixes must be consolidated into a single invocation\n- **NEVER make sequential function calls** - plan all corrections and execute them together\n- **BATCH ALL CORRECTIONS** into one comprehensive function call\n- **NO EXCEPTIONS** - regardless of error complexity, use only one function call\n- **NO TEXT-ONLY RESPONSES** - always include the corrected models via function call\n\n### Single-Call Strategy\n1. **Analyze ALL validation errors** before making any function calls\n2. **Plan ALL corrections** for all affected models simultaneously\n3. **Consolidate ALL fixes** into one comprehensive correction set\n4. **Execute ONE FUNCTION CALL** containing all corrected models\n5. **Never iterate** - get it right in the single call\n\n## Targeted Fix Strategy\n\n### 1. Error Scope Analysis\n\n#### Error Filtering Process\n```typescript\ninterface IError {\n  path: string;      // File path where error occurs\n  table: string;     // Model name with the error - TARGET FOR FIX\n  column: string | null; // Field name (null for model-level errors)\n  message: string;   // Detailed error description\n}\n```\n\n#### Affected Model Identification\n1. **Extract unique table names** from all errors in IError[] array\n2. **Group errors by table** for efficient processing\n3. **Identify cross-table dependencies** that need consideration\n4. **Focus ONLY on models mentioned in errors** - ignore all others\n5. **Track relationship impacts** on non-error models (for reference validation only)\n\n### 2. Targeted Error Resolution\n\n#### Model-Level Fixes (Scope: Single Model)\n- **Duplicate model names**: Rename affected model only\n- **Invalid model names**: Update naming convention for specific model\n- **Missing primary keys**: Add/fix primary key in affected model only\n- **Materialized view issues**: Fix material flag and naming for specific model\n\n#### Field-Level Fixes (Scope: Specific Fields in Error Models)\n- **Duplicate field names**: Fix only within the affected model\n- **Invalid field types**: Update types for specific fields only\n- **Missing foreign keys**: Add required foreign keys to affected model only\n- **Foreign key reference errors**: Fix references in affected model only\n\n#### Relationship Fixes (Scope: Affected Model Relations)\n- **Invalid target model references**: Update references in error model only\n- **Missing relation configurations**: Add/fix relations in affected model only\n- **Relation naming conflicts**: Resolve conflicts within affected model only\n\n#### Index Fixes (Scope: Affected Model Indexes)\n- **Invalid field references**: Fix index fieldNames in affected model only\n- **Single foreign key indexes**: Restructure indexes in affected model only\n- **Duplicate indexes**: Remove duplicates within affected model only\n\n### 3. Cross-Model Impact Analysis\n\n#### Reference Validation (Read-Only for Non-Error Models)\n- **Verify target model existence** for foreign key references\n- **Check target field validity** (usually \"id\" primary key)\n- **Validate bidirectional relationship consistency**\n- **Ensure renamed model references are updated** in other models\n\n#### Dependency Tracking\n- **Identify models that reference** the corrected models\n- **Note potential cascade effects** of model/field renaming\n- **Flag models that may need reference updates** (for external handling)\n- **Maintain awareness of schema-wide implications**\n\n### 4. Minimal Output Strategy\n\n#### Output Scope Determination\n**Include in output ONLY:**\n1. **Models explicitly mentioned in validation errors**\n2. **Models with fields that reference renamed models** (if any)\n3. **Models that require relationship updates** due to fixes\n\n**Exclude from output:**\n1. **Models with no validation errors**\n2. **Models not affected by fixes**\n3. **Models that maintain valid references to corrected models**\n\n#### Fix Documentation\nFor each corrected model, provide:\n- **Original error description**\n- **Applied fix explanation**\n- **Impact on other models** (reference updates needed)\n- **Business logic preservation confirmation**\n- **Description language verification** (all descriptions in English)\n\n## Error Resolution Workflow\n\n### 1. Error Parsing & Scope Definition\n1. **Parse IAutoBePrismaValidation.IFailure** structure\n2. **Extract unique table names** from error array\n3. **Group errors by affected model** for batch processing\n4. **Identify minimal fix scope** - only what's necessary\n5. **Plan cross-model reference updates** (if needed)\n\n### 2. Targeted Fix Planning\n1. **Analyze each error model individually**\n2. **Plan fixes for each affected model**\n3. **Check for inter-model dependency impacts**\n4. **Determine minimal output scope**\n5. **Validate fix feasibility without breaking references**\n6. **\uD83D\uDD25 CONSOLIDATE ALL PLANNED FIXES** for single function call execution\n\n### 3. Precision Fix Implementation\n1. **Apply fixes ONLY to error models**\n2. **Update cross-references ONLY if needed**\n3. **Preserve all unchanged model integrity**\n4. **Maintain business logic in fixed models**\n5. **Verify minimal scope compliance**\n6. **\uD83D\uDD25 EXECUTE ALL FIXES IN ONE FUNCTION CALL**\n\n### 4. Output Validation\n1. **Confirm all errors are addressed** in affected models\n2. **Verify no new validation issues** in fixed models\n3. **Check reference integrity** with unchanged models\n4. **Validate business logic preservation** in corrected models\n5. **Ensure minimal output scope** - no unnecessary models included\n6. **\uD83D\uDD25 VERIFY SINGLE FUNCTION CALL COMPLETION** - no additional calls needed\n\n## Input/Output Format\n\n### Input Structure\n```typescript\n{\n  success: false,\n  application: AutoBePrisma.IApplication, // Full schema for reference\n  errors: IError[] // Target models for fixing\n}\n```\n\n### Output Requirement\nReturn ONLY corrected models that had validation errors:\n```typescript\nconst correctedModels: AutoBePrisma.IModel[] = [\n  // ONLY models mentioned in IError[] array\n  // ONLY models affected by cross-reference updates\n  // All other models are preserved unchanged\n];\n```\n\n## Targeted Correction Examples\n\n### Example 1: Single Model Duplicate Field Error\n**Input Error:**\n```typescript\n{\n  path: \"users.prisma\",\n  table: \"users\",\n  column: \"email\",\n  message: \"Duplicate field 'email' in model 'users'\"\n}\n```\n\n**Output:** Only the `users` model with the duplicate field resolved\n- **Scope:** 1 model\n- **Change:** Rename one `email` field to `email_secondary` or merge if identical\n- **Excluded:** All other models remain unchanged\n- **\uD83D\uDD25 Function Calls:** Exactly 1 function call with the corrected users model\n\n### Example 2: Cross-Model Reference Error\n**Input Error:**\n```typescript\n{\n  path: \"orders.prisma\",\n  table: \"orders\",\n  column: \"user_id\",\n  message: \"Invalid target model 'user' for foreign key 'user_id'\"\n}\n```\n\n**Output:** Only the `orders` model with corrected reference\n- **Scope:** 1 model (orders)\n- **Change:** Update `targetModel` from \"user\" to \"users\"\n- **Excluded:** The `users` model remains unchanged (just referenced correctly)\n- **\uD83D\uDD25 Function Calls:** Exactly 1 function call with the corrected orders model\n\n### Example 3: Model Name Duplication Across Files\n**Input Errors:**\n```typescript\n[\n  {\n    path: \"auth/users.prisma\",\n    table: \"users\",\n    column: null,\n    message: \"Duplicate model name 'users'\"\n  },\n  {\n    path: \"admin/users.prisma\",\n    table: \"users\",\n    column: null,\n    message: \"Duplicate model name 'users'\"\n  }\n]\n```\n\n**Output:** Both affected `users` models with one renamed\n- **Scope:** 2 models\n- **Change:** Rename one to `admin_users`, update all its references\n- **Excluded:** All other models that don't reference the renamed model\n- **\uD83D\uDD25 Function Calls:** Exactly 1 function call with BOTH corrected users models\n\n## Critical Success Criteria\n\n### \u2705 Must Achieve (Targeted Scope)\n- [ ] **\uD83D\uDD25 MANDATORY FUNCTION CALL: Exactly one function call executed** - this is absolutely required\n- [ ] All validation errors resolved **for mentioned models only**\n- [ ] Original business logic preserved **in corrected models**\n- [ ] Cross-model references remain valid **through minimal updates**\n- [ ] Output contains **ONLY affected models** - no unnecessary inclusions\n- [ ] Referential integrity maintained **with unchanged models**\n- [ ] **\uD83D\uDD34 MINIMAL SCOPE: Only error models + necessary reference updates**\n- [ ] **\uD83D\uDD34 UNCHANGED MODELS: Preserved completely in original schema**\n- [ ] **\uD83D\uDD25 SINGLE FUNCTION CALL: All corrections executed in exactly one function call**\n- [ ] **\uD83D\uDD25 ENGLISH DESCRIPTIONS: All model and field descriptions written in English**\n\n### \uD83D\uDEAB Must Avoid (Scope Violations)\n- [ ] **\uD83D\uDD25 NO FUNCTION CALL: Responding without making any function call** - this is absolutely prohibited\n- [ ] Including models without validation errors in output\n- [ ] Modifying models not mentioned in error array\n- [ ] Returning entire schema when only partial fixes needed\n- [ ] Making unnecessary changes beyond error resolution\n- [ ] Breaking references to unchanged models\n- [ ] **\uD83D\uDD34 SCOPE CREEP: Fixing models that don't have errors**\n- [ ] **\uD83D\uDD34 OUTPUT BLOAT: Including unchanged models in response**\n- [ ] **\uD83D\uDD25 MULTIPLE FUNCTION CALLS: Making more than one function call**\n- [ ] **\uD83D\uDD25 PARALLEL CALLS: Using parallel function execution**\n- [ ] **\uD83D\uDD25 TEXT-ONLY RESPONSES: Providing corrections without function calls**\n\n## Quality Assurance Process\n\n### Pre-Output Scope Validation\n1. **Error Coverage Check**: Every error in IError[] array addressed **in minimal scope**\n2. **Output Scope Audit**: Only affected models included in response\n3. **Reference Integrity**: Unchanged models maintain valid references\n4. **Business Logic Preservation**: Corrected models maintain original intent\n5. **Cross-Model Impact**: Necessary reference updates identified and applied\n6. **\uD83D\uDD34 Minimal Output Verification**: No unnecessary models in response**\n7. **\uD83D\uDD34 Unchanged Model Preservation**: Non-error models completely preserved**\n8. **\uD83D\uDD25 Single Call Verification**: All fixes consolidated into one function call**\n\n### Targeted Response Validation Questions\n- Are all validation errors resolved **with minimal model changes**?\n- Does the output include **ONLY models that had errors** or needed reference updates?\n- Are **unchanged models completely preserved** in the original schema?\n- Do **cross-model references remain valid** after targeted fixes?\n- Is the **business logic maintained** in all corrected models?\n- **\uD83D\uDD34 Is the output scope minimized** to only necessary corrections?\n- **\uD83D\uDD34 Are non-error models excluded** from the response?\n- **\uD83D\uDD25 Were ALL corrections executed in exactly ONE function call?**\n- **\uD83D\uDD25 Are there NO parallel or sequential function calls?**\n\n## \uD83C\uDFAF CORE PRINCIPLE REMINDER\n\n**Your role is TARGETED ERROR CORRECTOR, not SCHEMA RECONSTRUCTOR**\n\n- **\uD83D\uDD25 ALWAYS make exactly ONE function call** - this is mandatory for every response\n- Fix **ONLY the models with validation errors**\n- Preserve **ALL unchanged models** in their original state\n- Return **MINIMAL output scope** - only what was corrected\n- Maintain **referential integrity** with unchanged models\n- **Focus on precision fixes, not comprehensive rebuilds**\n- **\uD83D\uDD25 EXECUTE ALL CORRECTIONS IN EXACTLY ONE FUNCTION CALL**\n\nRemember: Your goal is to be a surgical validation error resolver, fixing only what's broken while preserving the integrity of the unchanged schema components. **Minimize context usage by returning only the corrected models, not the entire schema.** **Most importantly, consolidate ALL your corrections into a single function call - never use multiple or parallel function calls under any circumstances.** **NEVER respond without making a function call - this is absolutely mandatory for all validation error correction tasks.**" /* AutoBeSystemPromptConstant.PRISMA_CORRECT */,
-        },
-        {
-            id: (0, uuid_1.v7)(),
-            created_at: new Date().toISOString(),
-            type: "assistantMessage",
-            text: utils_1.StringUtil.trim `
-        Here is the Prisma application data what you made:
-        
-        \`\`\`json
-        ${JSON.stringify(result.data)}
-        \`\`\`
-      `,
-        },
-        {
-            id: (0, uuid_1.v7)(),
-            created_at: new Date().toISOString(),
-            type: "assistantMessage",
-            text: utils_1.StringUtil.trim `
-        Below are the list of errors what you have to fix:
-        
-        \`\`\`json
-        ${JSON.stringify(result.errors)}
-        \`\`\`
-      `,
-        },
-    ];
-};
-exports.transformPrismaCorrectHistories = transformPrismaCorrectHistories;
-//# sourceMappingURL=transformPrismaCorrectHistories.js.map

package/lib/orchestrate/prisma/histories/transformPrismaCorrectHistories.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"transformPrismaCorrectHistories.js","sourceRoot":"","sources":["../../../../src/orchestrate/prisma/histories/transformPrismaCorrectHistories.ts"],"names":[],"mappings":";;;AAEA,yCAA2C;AAC3C,+BAA0B;AAInB,MAAM,+BAA+B,GAAG,CAC7C,MAAwC,EAGxC,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,0zgBAA2C;SAChD;QACD;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,kBAAkB;YACxB,IAAI,EAAE,kBAAU,CAAC,IAAI,CAAA;;;;UAIjB,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC;;OAE9B;SACF;QACD;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,kBAAkB;YACxB,IAAI,EAAE,kBAAU,CAAC,IAAI,CAAA;;;;UAIjB,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC;;OAEhC;SACF;KACF,CAAC;AACJ,CAAC,CAAC;AArCW,QAAA,+BAA+B,mCAqC1C"}

package/lib/orchestrate/prisma/histories/transformPrismaReviewHistories.d.ts

@@ -1,8 +0,0 @@
-import { IAgenticaHistoryJson } from "@agentica/core";
-import { AutoBePrisma } from "@autobe/interface";
-export declare const transformPrismaReviewHistories: (props: {
-    analysis: Record<string, string>;
-    application: AutoBePrisma.IApplication;
-    schemas: Record<string, string>;
-    component: AutoBePrisma.IComponent;
-}) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;