@autobe/agent 0.16.1 → 0.18.0

package/lib/{orchestrate → agent/src/orchestrate}/prisma/orchestratePrismaComponent.js

@@ -47,46 +47,31 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.orchestratePrismaComponents = orchestratePrismaComponents;
 const __typia_transform__validateReport = __importStar(require("typia/lib/internal/_validateReport.js"));
-const core_1 = require("@agentica/core");
 const typia_1 = __importDefault(require("typia"));
 const uuid_1 = require("uuid");
 const assertSchemaModel_1 = require("../../context/assertSchemaModel");
-const transformPrismaComponentsHistories_1 = require("./transformPrismaComponentsHistories");
+const transformPrismaComponentsHistories_1 = require("./histories/transformPrismaComponentsHistories");
 function orchestratePrismaComponents(ctx_1) {
-    return __awaiter(this, arguments, void 0, function* (ctx, content = "Please extract files and tables from the given documents.") {
-        var _a, _b, _c, _d, _e, _f;
+    return __awaiter(this, arguments, void 0, function* (ctx, message = "Please extract files and tables from the given documents.") {
+        var _a, _b, _c, _d, _e;
         const start = new Date();
         const pointer = {
             value: null,
         };
         const prefix = (_b = (_a = ctx.state().analyze) === null || _a === void 0 ? void 0 : _a.prefix) !== null && _b !== void 0 ? _b : null;
-        const agentica = new core_1.MicroAgentica({
-            model: ctx.model,
-            vendor: ctx.vendor,
-            config: Object.assign(Object.assign({}, ((_c = ctx.config) !== null && _c !== void 0 ? _c : {})), { executor: {
-                    describe: null,
-                } }),
+        const { histories, tokenUsage } = yield ctx.conversate({
+            source: "prismaComponents",
             histories: (0, transformPrismaComponentsHistories_1.transformPrismaComponentsHistories)(ctx.state(), prefix),
-            controllers: [
-                createApplication({
-                    model: ctx.model,
-                    build: (next) => {
-                        var _a;
-                        (_a = pointer.value) !== null && _a !== void 0 ? _a : (pointer.value = {
-                            components: [],
-                        });
-                        pointer.value.components.push(...next.components);
-                    },
-                }),
-            ],
-        });
-        const histories = yield agentica
-            .conversate(content)
-            .finally(() => {
-            const tokenUsage = agentica.getTokenUsage();
-            ctx.usage().record(tokenUsage, ["prisma"]);
+            controller: createController({
+                model: ctx.model,
+                build: (next) => {
+                    pointer.value = next;
+                },
+            }),
+            enforceFunctionCall: false,
+            message,
         });
-        if (((_d = histories.at(-1)) === null || _d === void 0 ? void 0 : _d.type) === "assistantMessage")
+        if (((_c = histories.at(-1)) === null || _c === void 0 ? void 0 : _c.type) === "assistantMessage")
             return Object.assign(Object.assign({}, histories.at(-1)), { created_at: start.toISOString(), completed_at: new Date().toISOString(), id: (0, uuid_1.v4)() });
         else if (pointer.value === null) {
             throw new Error("Failed to extract files and tables."); // unreachable
@@ -94,12 +79,16 @@ function orchestratePrismaComponents(ctx_1) {
         return {
             type: "prismaComponents",
             created_at: start.toISOString(),
+            thinking: pointer.value.thinking,
+            review: pointer.value.review,
+            decision: pointer.value.decision,
             components: pointer.value.components,
-            step: (_f = (_e = ctx.state().analyze) === null || _e === void 0 ? void 0 : _e.step) !== null && _f !== void 0 ? _f : 0,
+            tokenUsage,
+            step: (_e = (_d = ctx.state().analyze) === null || _d === void 0 ? void 0 : _d.step) !== null && _e !== void 0 ? _e : 0,
         };
     });
 }
-function createApplication(props) {
+function createController(props) {
     (0, assertSchemaModel_1.assertSchemaModel)(props.model);
     const application = collection[props.model];
     return {
@@ -123,18 +112,34 @@ const claude = {
         {
             name: "extractComponents",
             parameters: {
-                description: " - Configuration object containing the file-to-table mapping\nstructure\n\n------------------------------\n\nCurrent Type: {@link IExtractComponentsProps}",
+                description: "Current Type: {@link IAutoBePrismaComponentApplication.IProps}",
                 type: "object",
                 properties: {
+                    thinking: {
+                        description: "Initial thoughts on namespace classification criteria.\n\nContains the AI agent's initial analysis and reasoning about how to\norganize tables into different business domains/namespaces.\n\n**Example:**\n\n    \"Based on the business requirements, I identify several key domains:\n    - User-related entities should be grouped under 'Actors' namespace\n    - Product and sales information under 'Sales' namespace\n    - System configuration under 'Systematic' namespace\"",
+                        type: "string"
+                    },
+                    review: {
+                        description: "Review and refinement of the namespace classification.\n\nContains the AI agent's review process, considering relationships between\ntables and potential improvements to the initial classification.\n\n**Example:**\n\n    \"Upon review, I noticed that 'shopping_channel_categories' has strong\n    relationships with both channels and sales. However, since it primarily\n    defines the channel structure, it should remain in 'Systematic' namespace.\"",
+                        type: "string"
+                    },
+                    decision: {
+                        description: "Final decision on namespace classification.\n\nContains the AI agent's final reasoning and rationale for the chosen\nnamespace organization, explaining why this structure best serves the\nbusiness requirements.\n\n**Example:**\n\n    \"Final decision: Organize tables into 3 main namespaces:\n    1. Systematic - for channel and system configuration\n    2. Actors - for all user types (customers, citizens, administrators)\n    3. Sales - for product sales and related transactional data\n    This structure provides clear separation of concerns and follows DDD principles.\"",
+                        type: "string"
+                    },
                     components: {
-                        description: "Maps Prisma schema filenames to their contained database tables.\n\n**Structure:**\n\n- Key: Prisma schema filename with .prisma extension\n- Value: Array of table names defined in that file\n\n**Example:**\n\n```typescript\n{\n  {\n    filename: \"schema-01-users.prisma\",\n    tables: [\"user\", \"admin\", \"moderator\", \"user_profile\", \"user_settings\"]\n  },\n  {\n    filename: \"schema-02-articles.prisma\",\n    tables: [\"article\", \"article_snapshot\"]\n  },\n  {\n    filename: \"schema-03-comments.prisma\",\n    tables: [\"comment\", \"comment_like\"]\n  }\n}\n```\n\n**Notes:**\n\n- Table names must match exact Prisma model names (case-sensitive)\n- Keep mapping synchronized with actual schema files\n- Use consistent naming convention for files",
+                        description: "Array of domain components that group related database tables.\n\nEach component represents a business domain and becomes one Prisma schema\nfile. Common domains include: Actors (users), Sales (products), Orders,\nCarts, etc.\n\n**Example:**\n\n```typescript\n{\n  \"components\": [\n    {\n      \"filename\": \"schema-02-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, shopping_channel_categories connects channels and sales, but it fundamentally defines channel structure.\",\n      \"rationale\": \"Grouping all system configuration tables together provides a clear foundation layer that other domains can reference.\",\n      \"tables\": [\n        \"shopping_channels\",\n        \"shopping_sections\",\n        \"shopping_channel_categories\"\n      ]\n    },\n    {\n      \"filename\": \"schema-03-actors.prisma\",\n      \"namespace\": \"Actors\",\n      \"thinking\": \"All user-related entities should be grouped together as they share authentication and identity patterns.\",\n      \"review\": \"While customers interact with sales, the customer entity itself is about identity, not transactions.\",\n      \"rationale\": \"This component groups all actor-related tables to maintain separation between identity management and business transactions.\",\n      \"tables\": [\n        \"shopping_customers\",\n        \"shopping_citizens\",\n        \"shopping_administrators\"\n      ]\n    },\n    {\n      \"filename\": \"schema-04-sales.prisma\",\n      \"namespace\": \"Sales\",\n      \"thinking\": \"Product catalog and sales-related tables belong together as they form the core commerce functionality.\",\n      \"review\": \"Sales snapshots are integral to the sales domain for tracking product history and price changes.\",\n      \"rationale\": \"Consolidating all sales-related tables enables coherent management of the entire product lifecycle.\",\n      \"tables\": [\n        \"shopping_sales\",\n        \"shopping_sale_snapshots\",\n        \"shopping_sale_units\",\n        \"shopping_sale_unit_options\"\n      ]\n    }\n  ]\n}\n```\n\n**Notes:**\n\n- Table names must follow snake_case convention with domain prefix (e.g.,\n  `shopping_customers`)\n- Each component becomes one `.prisma` file containing related models\n- Filename numbering indicates dependency order for schema generation\n- Namespace is used for documentation organization and domain grouping",
                         type: "array",
                         items: {
                             $ref: "#/$defs/AutoBePrisma.IComponent"
-                        }
+                        },
+                        minItems: 1
                     }
                 },
                 required: [
+                    "thinking",
+                    "review",
+                    "decision",
                     "components"
                 ],
                 additionalProperties: false,
@@ -152,6 +157,18 @@ const claude = {
                                 description: "Business domain namespace that groups related models.\n\nUsed in Prisma documentation comments as \"@\\namespace directive\".\nExamples from uploaded schemas: \"Systematic\", \"Actors\", \"Sales\", \"Carts\",\n\"Orders\", \"Coupons\", \"Coins\", \"Inquiries\", \"Favorites\", \"Articles\"",
                                 type: "string"
                             },
+                            thinking: {
+                                description: "Initial thoughts on why these tables belong together.\n\n**Example:**\n\n    \"These tables all relate to user management and authentication.\n    They share common patterns like user identification and access control.\"",
+                                type: "string"
+                            },
+                            review: {
+                                description: "Review considerations for this component grouping.\n\n**Example:**\n\n    \"Reviewed relationships with other domains. While customers create orders,\n    the customer entity itself is fundamentally about user identity, not sales.\"",
+                                type: "string"
+                            },
+                            rationale: {
+                                description: "Final rationale for this component's composition.\n\n**Example:**\n\n    \"This component groups all actor-related tables to maintain a clear\n    separation between identity management and business transactions.\"",
+                                type: "string"
+                            },
                             tables: {
                                 description: "Array of table names that will be included in this component's schema\nfile.\n\nContains all database table names that belong to this business domain,\nensuring logical grouping and proper organization of related data\nstructures.",
                                 type: "array",
@@ -165,15 +182,34 @@ const claude = {
                         required: [
                             "filename",
                             "namespace",
+                            "thinking",
+                            "review",
+                            "rationale",
                             "tables"
                         ]
                     }
                 }
             },
-            description: "Extracts and organizes database schema files with their corresponding table\ndefinitions.\n\nProcesses Prisma schema files and maps each file to its contained database\ntables, enabling structured organization of schemas across multiple files\nfor large projects.",
-            validate: (() => { const _io0 = input => Array.isArray(input.components) && input.components.every(elem => "object" === typeof elem && null !== elem && _io1(elem)); const _io1 = input => "string" === typeof input.filename && RegExp("^[a-zA-Z0-9._-]+\\.prisma$").test(input.filename) && "string" === typeof input.namespace && (Array.isArray(input.tables) && (1 <= input.tables.length && input.tables.every(elem => "string" === typeof elem && RegExp("^[a-z][a-z0-9_]*$").test(elem)))); const _vo0 = (input, _path, _exceptionable = true) => [(Array.isArray(input.components) || _report(_exceptionable, {
+            description: "Organizes database tables into domain-based components for Prisma schema\ngeneration.\n\nTakes business requirements and groups related tables into logical domains,\nwith each component becoming a separate .prisma file.",
+            validate: (() => { const _io0 = input => "string" === typeof input.thinking && "string" === typeof input.review && "string" === typeof input.decision && (Array.isArray(input.components) && (1 <= input.components.length && input.components.every(elem => "object" === typeof elem && null !== elem && _io1(elem)))); const _io1 = input => "string" === typeof input.filename && RegExp("^[a-zA-Z0-9._-]+\\.prisma$").test(input.filename) && "string" === typeof input.namespace && "string" === typeof input.thinking && "string" === typeof input.review && "string" === typeof input.rationale && (Array.isArray(input.tables) && (1 <= input.tables.length && input.tables.every(elem => "string" === typeof elem && RegExp("^[a-z][a-z0-9_]*$").test(elem)))); const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.thinking || _report(_exceptionable, {
+                    path: _path + ".thinking",
+                    expected: "string",
+                    value: input.thinking
+                }), "string" === typeof input.review || _report(_exceptionable, {
+                    path: _path + ".review",
+                    expected: "string",
+                    value: input.review
+                }), "string" === typeof input.decision || _report(_exceptionable, {
+                    path: _path + ".decision",
+                    expected: "string",
+                    value: input.decision
+                }), (Array.isArray(input.components) || _report(_exceptionable, {
                     path: _path + ".components",
-                    expected: "Array<AutoBePrisma.IComponent>",
+                    expected: "(Array<AutoBePrisma.IComponent> & MinItems<1>)",
+                    value: input.components
+                })) && ((1 <= input.components.length || _report(_exceptionable, {
+                    path: _path + ".components",
+                    expected: "Array<> & MinItems<1>",
                     value: input.components
                 })) && input.components.map((elem, _index3) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
                     path: _path + ".components[" + _index3 + "]",
@@ -183,9 +219,9 @@ const claude = {
                     path: _path + ".components[" + _index3 + "]",
                     expected: "AutoBePrisma.IComponent",
                     value: elem
-                })).every(flag => flag) || _report(_exceptionable, {
+                })).every(flag => flag)) || _report(_exceptionable, {
                     path: _path + ".components",
-                    expected: "Array<AutoBePrisma.IComponent>",
+                    expected: "(Array<AutoBePrisma.IComponent> & MinItems<1>)",
                     value: input.components
                 })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.filename && (RegExp("^[a-zA-Z0-9._-]+\\.prisma$").test(input.filename) || _report(_exceptionable, {
                     path: _path + ".filename",
@@ -199,9 +235,21 @@ const claude = {
                     path: _path + ".namespace",
                     expected: "string",
                     value: input.namespace
+                }), "string" === typeof input.thinking || _report(_exceptionable, {
+                    path: _path + ".thinking",
+                    expected: "string",
+                    value: input.thinking
+                }), "string" === typeof input.review || _report(_exceptionable, {
+                    path: _path + ".review",
+                    expected: "string",
+                    value: input.review
+                }), "string" === typeof input.rationale || _report(_exceptionable, {
+                    path: _path + ".rationale",
+                    expected: "string",
+                    value: input.rationale
                 }), (Array.isArray(input.tables) || _report(_exceptionable, {
                     path: _path + ".tables",
-                    expected: "(Array<string & Pattern<\"^[a-z][a-z0-9_]*$\">> & MinItems<1>)",
+                    expected: "(Array<string & SnakePattern> & MinItems<1>)",
                     value: input.tables
                 })) && ((1 <= input.tables.length || _report(_exceptionable, {
                     path: _path + ".tables",
@@ -209,15 +257,15 @@ const claude = {
                     value: input.tables
                 })) && input.tables.map((elem, _index4) => "string" === typeof elem && (RegExp("^[a-z][a-z0-9_]*$").test(elem) || _report(_exceptionable, {
                     path: _path + ".tables[" + _index4 + "]",
-                    expected: "string & Pattern<\"^[a-z][a-z0-9_]*$\">",
+                    expected: "string & SnakePattern",
                     value: elem
                 })) || _report(_exceptionable, {
                     path: _path + ".tables[" + _index4 + "]",
-                    expected: "(string & Pattern<\"^[a-z][a-z0-9_]*$\">)",
+                    expected: "(string & SnakePattern)",
                     value: elem
                 })).every(flag => flag)) || _report(_exceptionable, {
                     path: _path + ".tables",
-                    expected: "(Array<string & Pattern<\"^[a-z][a-z0-9_]*$\">> & MinItems<1>)",
+                    expected: "(Array<string & SnakePattern> & MinItems<1>)",
                     value: input.tables
                 })].every(flag => flag); const __is = input => "object" === typeof input && null !== input && _io0(input); let errors; let _report; return input => {
                 if (false === __is(input)) {
@@ -225,11 +273,11 @@ const claude = {
                     _report = __typia_transform__validateReport._validateReport(errors);
                     ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
                         path: _path + "",
-                        expected: "IExtractComponentsProps",
+                        expected: "IAutoBePrismaComponentApplication.IProps",
                         value: input
                     })) && _vo0(input, _path + "", true) || _report(true, {
                         path: _path + "",
-                        expected: "IExtractComponentsProps",
+                        expected: "IAutoBePrismaComponentApplication.IProps",
                         value: input
                     }))(input, "$input", true);
                     const success = 0 === errors.length;
@@ -262,11 +310,23 @@ const collection = {
             {
                 name: "extractComponents",
                 parameters: {
-                    description: " - Configuration object containing the file-to-table mapping\nstructure\n\n------------------------------\n\nCurrent Type: {@link IExtractComponentsProps}",
+                    description: "Current Type: {@link IAutoBePrismaComponentApplication.IProps}",
                     type: "object",
                     properties: {
+                        thinking: {
+                            description: "Initial thoughts on namespace classification criteria.\n\nContains the AI agent's initial analysis and reasoning about how to\norganize tables into different business domains/namespaces.\n\n**Example:**\n\n    \"Based on the business requirements, I identify several key domains:\n    - User-related entities should be grouped under 'Actors' namespace\n    - Product and sales information under 'Sales' namespace\n    - System configuration under 'Systematic' namespace\"",
+                            type: "string"
+                        },
+                        review: {
+                            description: "Review and refinement of the namespace classification.\n\nContains the AI agent's review process, considering relationships between\ntables and potential improvements to the initial classification.\n\n**Example:**\n\n    \"Upon review, I noticed that 'shopping_channel_categories' has strong\n    relationships with both channels and sales. However, since it primarily\n    defines the channel structure, it should remain in 'Systematic' namespace.\"",
+                            type: "string"
+                        },
+                        decision: {
+                            description: "Final decision on namespace classification.\n\nContains the AI agent's final reasoning and rationale for the chosen\nnamespace organization, explaining why this structure best serves the\nbusiness requirements.\n\n**Example:**\n\n    \"Final decision: Organize tables into 3 main namespaces:\n    1. Systematic - for channel and system configuration\n    2. Actors - for all user types (customers, citizens, administrators)\n    3. Sales - for product sales and related transactional data\n    This structure provides clear separation of concerns and follows DDD principles.\"",
+                            type: "string"
+                        },
                         components: {
-                            description: "Maps Prisma schema filenames to their contained database tables.\n\n**Structure:**\n\n- Key: Prisma schema filename with .prisma extension\n- Value: Array of table names defined in that file\n\n**Example:**\n\n```typescript\n{\n  {\n    filename: \"schema-01-users.prisma\",\n    tables: [\"user\", \"admin\", \"moderator\", \"user_profile\", \"user_settings\"]\n  },\n  {\n    filename: \"schema-02-articles.prisma\",\n    tables: [\"article\", \"article_snapshot\"]\n  },\n  {\n    filename: \"schema-03-comments.prisma\",\n    tables: [\"comment\", \"comment_like\"]\n  }\n}\n```\n\n**Notes:**\n\n- Table names must match exact Prisma model names (case-sensitive)\n- Keep mapping synchronized with actual schema files\n- Use consistent naming convention for files",
+                            description: "Array of domain components that group related database tables.\n\nEach component represents a business domain and becomes one Prisma schema\nfile. Common domains include: Actors (users), Sales (products), Orders,\nCarts, etc.\n\n**Example:**\n\n```typescript\n{\n  \"components\": [\n    {\n      \"filename\": \"schema-02-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, shopping_channel_categories connects channels and sales, but it fundamentally defines channel structure.\",\n      \"rationale\": \"Grouping all system configuration tables together provides a clear foundation layer that other domains can reference.\",\n      \"tables\": [\n        \"shopping_channels\",\n        \"shopping_sections\",\n        \"shopping_channel_categories\"\n      ]\n    },\n    {\n      \"filename\": \"schema-03-actors.prisma\",\n      \"namespace\": \"Actors\",\n      \"thinking\": \"All user-related entities should be grouped together as they share authentication and identity patterns.\",\n      \"review\": \"While customers interact with sales, the customer entity itself is about identity, not transactions.\",\n      \"rationale\": \"This component groups all actor-related tables to maintain separation between identity management and business transactions.\",\n      \"tables\": [\n        \"shopping_customers\",\n        \"shopping_citizens\",\n        \"shopping_administrators\"\n      ]\n    },\n    {\n      \"filename\": \"schema-04-sales.prisma\",\n      \"namespace\": \"Sales\",\n      \"thinking\": \"Product catalog and sales-related tables belong together as they form the core commerce functionality.\",\n      \"review\": \"Sales snapshots are integral to the sales domain for tracking product history and price changes.\",\n      \"rationale\": \"Consolidating all sales-related tables enables coherent management of the entire product lifecycle.\",\n      \"tables\": [\n        \"shopping_sales\",\n        \"shopping_sale_snapshots\",\n        \"shopping_sale_units\",\n        \"shopping_sale_unit_options\"\n      ]\n    }\n  ]\n}\n```\n\n**Notes:**\n\n- Table names must follow snake_case convention with domain prefix (e.g.,\n  `shopping_customers`)\n- Each component becomes one `.prisma` file containing related models\n- Filename numbering indicates dependency order for schema generation\n- Namespace is used for documentation organization and domain grouping\n\n\n@minItems 1",
                             type: "array",
                             items: {
                                 $ref: "#/$defs/AutoBePrisma.IComponent"
@@ -274,6 +334,9 @@ const collection = {
                         }
                     },
                     required: [
+                        "thinking",
+                        "review",
+                        "decision",
                         "components"
                     ],
                     additionalProperties: false,
@@ -290,6 +353,18 @@ const collection = {
                                     description: "Business domain namespace that groups related models.\n\nUsed in Prisma documentation comments as \"@\\namespace directive\".\nExamples from uploaded schemas: \"Systematic\", \"Actors\", \"Sales\", \"Carts\",\n\"Orders\", \"Coupons\", \"Coins\", \"Inquiries\", \"Favorites\", \"Articles\"",
                                     type: "string"
                                 },
+                                thinking: {
+                                    description: "Initial thoughts on why these tables belong together.\n\n**Example:**\n\n    \"These tables all relate to user management and authentication.\n    They share common patterns like user identification and access control.\"",
+                                    type: "string"
+                                },
+                                review: {
+                                    description: "Review considerations for this component grouping.\n\n**Example:**\n\n    \"Reviewed relationships with other domains. While customers create orders,\n    the customer entity itself is fundamentally about user identity, not sales.\"",
+                                    type: "string"
+                                },
+                                rationale: {
+                                    description: "Final rationale for this component's composition.\n\n**Example:**\n\n    \"This component groups all actor-related tables to maintain a clear\n    separation between identity management and business transactions.\"",
+                                    type: "string"
+                                },
                                 tables: {
                                     description: "Array of table names that will be included in this component's schema\nfile.\n\nContains all database table names that belong to this business domain,\nensuring logical grouping and proper organization of related data\nstructures.\n\n\n@minItems 1",
                                     type: "array",
@@ -302,15 +377,34 @@ const collection = {
                             required: [
                                 "filename",
                                 "namespace",
+                                "thinking",
+                                "review",
+                                "rationale",
                                 "tables"
                             ]
                         }
                     }
                 },
-                description: "Extracts and organizes database schema files with their corresponding table\ndefinitions.\n\nProcesses Prisma schema files and maps each file to its contained database\ntables, enabling structured organization of schemas across multiple files\nfor large projects.",
-                validate: (() => { const _io0 = input => Array.isArray(input.components) && input.components.every(elem => "object" === typeof elem && null !== elem && _io1(elem)); const _io1 = input => "string" === typeof input.filename && RegExp("^[a-zA-Z0-9._-]+\\.prisma$").test(input.filename) && "string" === typeof input.namespace && (Array.isArray(input.tables) && (1 <= input.tables.length && input.tables.every(elem => "string" === typeof elem && RegExp("^[a-z][a-z0-9_]*$").test(elem)))); const _vo0 = (input, _path, _exceptionable = true) => [(Array.isArray(input.components) || _report(_exceptionable, {
+                description: "Organizes database tables into domain-based components for Prisma schema\ngeneration.\n\nTakes business requirements and groups related tables into logical domains,\nwith each component becoming a separate .prisma file.",
+                validate: (() => { const _io0 = input => "string" === typeof input.thinking && "string" === typeof input.review && "string" === typeof input.decision && (Array.isArray(input.components) && (1 <= input.components.length && input.components.every(elem => "object" === typeof elem && null !== elem && _io1(elem)))); const _io1 = input => "string" === typeof input.filename && RegExp("^[a-zA-Z0-9._-]+\\.prisma$").test(input.filename) && "string" === typeof input.namespace && "string" === typeof input.thinking && "string" === typeof input.review && "string" === typeof input.rationale && (Array.isArray(input.tables) && (1 <= input.tables.length && input.tables.every(elem => "string" === typeof elem && RegExp("^[a-z][a-z0-9_]*$").test(elem)))); const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.thinking || _report(_exceptionable, {
+                        path: _path + ".thinking",
+                        expected: "string",
+                        value: input.thinking
+                    }), "string" === typeof input.review || _report(_exceptionable, {
+                        path: _path + ".review",
+                        expected: "string",
+                        value: input.review
+                    }), "string" === typeof input.decision || _report(_exceptionable, {
+                        path: _path + ".decision",
+                        expected: "string",
+                        value: input.decision
+                    }), (Array.isArray(input.components) || _report(_exceptionable, {
+                        path: _path + ".components",
+                        expected: "(Array<AutoBePrisma.IComponent> & MinItems<1>)",
+                        value: input.components
+                    })) && ((1 <= input.components.length || _report(_exceptionable, {
                         path: _path + ".components",
-                        expected: "Array<AutoBePrisma.IComponent>",
+                        expected: "Array<> & MinItems<1>",
                         value: input.components
                     })) && input.components.map((elem, _index3) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
                         path: _path + ".components[" + _index3 + "]",
@@ -320,9 +414,9 @@ const collection = {
                         path: _path + ".components[" + _index3 + "]",
                         expected: "AutoBePrisma.IComponent",
                         value: elem
-                    })).every(flag => flag) || _report(_exceptionable, {
+                    })).every(flag => flag)) || _report(_exceptionable, {
                         path: _path + ".components",
-                        expected: "Array<AutoBePrisma.IComponent>",
+                        expected: "(Array<AutoBePrisma.IComponent> & MinItems<1>)",
                         value: input.components
                     })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.filename && (RegExp("^[a-zA-Z0-9._-]+\\.prisma$").test(input.filename) || _report(_exceptionable, {
                         path: _path + ".filename",
@@ -336,9 +430,21 @@ const collection = {
                         path: _path + ".namespace",
                         expected: "string",
                         value: input.namespace
+                    }), "string" === typeof input.thinking || _report(_exceptionable, {
+                        path: _path + ".thinking",
+                        expected: "string",
+                        value: input.thinking
+                    }), "string" === typeof input.review || _report(_exceptionable, {
+                        path: _path + ".review",
+                        expected: "string",
+                        value: input.review
+                    }), "string" === typeof input.rationale || _report(_exceptionable, {
+                        path: _path + ".rationale",
+                        expected: "string",
+                        value: input.rationale
                     }), (Array.isArray(input.tables) || _report(_exceptionable, {
                         path: _path + ".tables",
-                        expected: "(Array<string & Pattern<\"^[a-z][a-z0-9_]*$\">> & MinItems<1>)",
+                        expected: "(Array<string & SnakePattern> & MinItems<1>)",
                         value: input.tables
                     })) && ((1 <= input.tables.length || _report(_exceptionable, {
                         path: _path + ".tables",
@@ -346,15 +452,15 @@ const collection = {
                         value: input.tables
                     })) && input.tables.map((elem, _index4) => "string" === typeof elem && (RegExp("^[a-z][a-z0-9_]*$").test(elem) || _report(_exceptionable, {
                         path: _path + ".tables[" + _index4 + "]",
-                        expected: "string & Pattern<\"^[a-z][a-z0-9_]*$\">",
+                        expected: "string & SnakePattern",
                         value: elem
                     })) || _report(_exceptionable, {
                         path: _path + ".tables[" + _index4 + "]",
-                        expected: "(string & Pattern<\"^[a-z][a-z0-9_]*$\">)",
+                        expected: "(string & SnakePattern)",
                         value: elem
                     })).every(flag => flag)) || _report(_exceptionable, {
                         path: _path + ".tables",
-                        expected: "(Array<string & Pattern<\"^[a-z][a-z0-9_]*$\">> & MinItems<1>)",
+                        expected: "(Array<string & SnakePattern> & MinItems<1>)",
                         value: input.tables
                     })].every(flag => flag); const __is = input => "object" === typeof input && null !== input && _io0(input); let errors; let _report; return input => {
                     if (false === __is(input)) {
@@ -362,11 +468,11 @@ const collection = {
                         _report = __typia_transform__validateReport._validateReport(errors);
                         ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
                             path: _path + "",
-                            expected: "IExtractComponentsProps",
+                            expected: "IAutoBePrismaComponentApplication.IProps",
                             value: input
                         })) && _vo0(input, _path + "", true) || _report(true, {
                             path: _path + "",
-                            expected: "IExtractComponentsProps",
+                            expected: "IAutoBePrismaComponentApplication.IProps",
                             value: input
                         }))(input, "$input", true);
                         const success = 0 === errors.length;

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

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

package/lib/agent/src/orchestrate/prisma/orchestratePrismaCorrect.d.ts

@@ -0,0 +1,4 @@
+import { AutoBePrisma, IAutoBePrismaValidation } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../context/AutoBeContext";
+export declare function orchestratePrismaCorrect<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, application: AutoBePrisma.IApplication, life?: number): Promise<IAutoBePrismaValidation>;