@autobe/agent 0.27.0 → 0.28.1

package/lib/orchestrate/interface/orchestrateInterfaceGroups.js

@@ -88,7 +88,11 @@ function orchestrateInterfaceGroups(ctx, props) {
 }
 function createController(props) {
     (0, assertSchemaModel_1.assertSchemaModel)(props.model);
-    const application = collection[props.model];
+    const application = collection[props.model === "chatgpt"
+        ? "chatgpt"
+        : props.model === "gemini"
+            ? "gemini"
+            : "claude"];
     return {
         protocol: "class",
         name: "interface",
@@ -100,243 +104,355 @@ function createController(props) {
         },
     };
 }
-const claude = {
-    model: "claude",
-    options: {
-        reference: true,
-        separate: null
-    },
-    functions: [
-        {
-            name: "makeGroups",
-            parameters: {
-                description: " Properties containing the groups to be created for API\norganization\n\n------------------------------\n\nCurrent Type: {@link IAutoBeInterfaceGroupApplication.IProps}",
-                type: "object",
-                properties: {
-                    groups: {
-                        description: "Array of API endpoint groups for organizing development.\n\nDO: Organize groups around existing Prisma schema structure.\nDO: Provide complete coverage of all entities and requirements without\noverlap.",
-                        type: "array",
-                        items: {
-                            $ref: "#/$defs/IAutoBeInterfaceGroupApplication.IGroup"
-                        },
-                        minItems: 1
+const collection = {
+    chatgpt: {
+        model: "chatgpt",
+        options: {
+            reference: true,
+            strict: false,
+            separate: null
+        },
+        functions: [
+            {
+                name: "makeGroups",
+                parameters: {
+                    description: " Properties containing the groups to be created for API\norganization\n\n------------------------------\n\nCurrent Type: {@link IAutoBeInterfaceGroupApplication.IProps}",
+                    type: "object",
+                    properties: {
+                        groups: {
+                            description: "Array of API endpoint groups for organizing development.\n\nDO: Organize groups around existing Prisma schema structure.\nDO: Provide complete coverage of all entities and requirements without\noverlap.\n\n\n@minItems 1",
+                            type: "array",
+                            items: {
+                                $ref: "#/$defs/IAutoBeInterfaceGroupApplication.IGroup"
+                            }
+                        }
+                    },
+                    required: [
+                        "groups"
+                    ],
+                    additionalProperties: false,
+                    $defs: {
+                        "IAutoBeInterfaceGroupApplication.IGroup": {
+                            description: "Definition of a logical API endpoint group based on Prisma schema\norganization.\n\n**SCHEMA-BASED GROUP REQUIREMENTS:**\n\nDO: Derive groups from the Prisma schema structure rather than arbitrary\nbusiness domain names.\n\nThis ensures consistency with the underlying data model and prevents\nmisalignment between API organization and database structure.\n\n**Primary Group Sources (in order of priority):**\n\n1. **Prisma Schema Namespaces**: Use namespace names (e.g., `namespace\n   Shopping` \u2192 \"Shopping\")\n2. **Schema File Names**: Derive from file names (e.g., `shopping.prisma` \u2192\n   \"Shopping\")\n3. **Table Prefix Patterns**: Use consistent prefixes (e.g., `shopping_orders`\n   \u2192 \"Shopping\")\n4. **Schema Comments/Annotations**: Follow organizational comments in schema\n\n**Group Creation Guidelines:**\n\n- Each group covers specific Prisma schema entities without overlap\n- Size groups appropriately for manageable endpoint generation cycles\n- Maintain clear boundaries based on schema organization\n- Ensure complete coverage of all database entities and requirements\n- Related database tables within the same schema area are grouped together\n\n**When to Create Schema-Independent Groups:**\n\nOnly create groups that don't correspond to Prisma schema organization\nwhen:\n\n- Requirements include functionality not represented in any schema entity\n- Cross-cutting concerns span multiple schema areas\n- Integration operations don't map to specific database entities\n- System-level functionality requires dedicated API operations\n\n**Naming Standards:**\n\n- Use PascalCase format (e.g., \"Shopping\", \"BBS\", \"UserManagement\")\n- Names directly reflect Prisma schema structure\n- Keep names concise and schema-derived\n- Avoid arbitrary business domain names\n- Maintain consistency with schema organization\n\n**Quality Requirements:**\n\n- Groups collectively cover ALL entities and requirements\n- Each database entity belongs to exactly one group\n- Clear mapping to specific Prisma schema elements\n- Balance group sizes within schema constraints\n- Follow existing schema namespace or file structure patterns",
+                            type: "object",
+                            properties: {
+                                name: {
+                                    description: "Unique identifier name derived from Prisma schema structure.\n\nDO: Correspond to schema namespaces, file names, table prefixes, or\norganizational annotations rather than arbitrary business domain names.\n\n\n@minLength 1",
+                                    type: "string"
+                                },
+                                description: {
+                                    description: "Concise description of the group's core purpose.\n\n**Requirements:**\n- Keep it brief and focused (50-200 characters)\n- State the main purpose and key entities\n- Avoid detailed explanations or mappings\n\nExample: \"Handles shopping-related entities and operations\"\n\n\n@minLength 1",
+                                    type: "string"
+                                }
+                            },
+                            required: [
+                                "name",
+                                "description"
+                            ]
+                        }
                     }
                 },
-                required: [
-                    "groups"
-                ],
-                additionalProperties: false,
-                $defs: {
-                    "IAutoBeInterfaceGroupApplication.IGroup": {
-                        description: "Definition of a logical API endpoint group based on Prisma schema\norganization.\n\n**SCHEMA-BASED GROUP REQUIREMENTS:**\n\nDO: Derive groups from the Prisma schema structure rather than arbitrary\nbusiness domain names.\n\nThis ensures consistency with the underlying data model and prevents\nmisalignment between API organization and database structure.\n\n**Primary Group Sources (in order of priority):**\n\n1. **Prisma Schema Namespaces**: Use namespace names (e.g., `namespace\n   Shopping` \u2192 \"Shopping\")\n2. **Schema File Names**: Derive from file names (e.g., `shopping.prisma` \u2192\n   \"Shopping\")\n3. **Table Prefix Patterns**: Use consistent prefixes (e.g., `shopping_orders`\n   \u2192 \"Shopping\")\n4. **Schema Comments/Annotations**: Follow organizational comments in schema\n\n**Group Creation Guidelines:**\n\n- Each group covers specific Prisma schema entities without overlap\n- Size groups appropriately for manageable endpoint generation cycles\n- Maintain clear boundaries based on schema organization\n- Ensure complete coverage of all database entities and requirements\n- Related database tables within the same schema area are grouped together\n\n**When to Create Schema-Independent Groups:**\n\nOnly create groups that don't correspond to Prisma schema organization\nwhen:\n\n- Requirements include functionality not represented in any schema entity\n- Cross-cutting concerns span multiple schema areas\n- Integration operations don't map to specific database entities\n- System-level functionality requires dedicated API operations\n\n**Naming Standards:**\n\n- Use PascalCase format (e.g., \"Shopping\", \"BBS\", \"UserManagement\")\n- Names directly reflect Prisma schema structure\n- Keep names concise and schema-derived\n- Avoid arbitrary business domain names\n- Maintain consistency with schema organization\n\n**Quality Requirements:**\n\n- Groups collectively cover ALL entities and requirements\n- Each database entity belongs to exactly one group\n- Clear mapping to specific Prisma schema elements\n- Balance group sizes within schema constraints\n- Follow existing schema namespace or file structure patterns",
-                        type: "object",
-                        properties: {
-                            name: {
-                                description: "Unique identifier name derived from Prisma schema structure.\n\nDO: Correspond to schema namespaces, file names, table prefixes, or\norganizational annotations rather than arbitrary business domain names.",
-                                type: "string",
-                                minLength: 1
-                            },
-                            description: {
-                                description: "Concise description of the group's core purpose.\n\n**Requirements:**\n- Keep it brief and focused (50-200 characters)\n- State the main purpose and key entities\n- Avoid detailed explanations or mappings\n\nExample: \"Handles shopping-related entities and operations\"",
-                                type: "string",
-                                minLength: 1
-                            }
-                        },
-                        required: [
-                            "name",
-                            "description"
-                        ]
+                description: "Generate logical groups for organizing API endpoint creation based on\nPrisma schema structure.\n\nDO: Derive groups from Prisma schema organization (namespaces, file\nstructure, table prefixes) rather than arbitrary business domains.\nDO: Create new groups only when existing schema structure cannot adequately\ncover all requirements.",
+                validate: (() => { const _io0 = input => Array.isArray(input.groups) && (1 <= input.groups.length && input.groups.every(elem => "object" === typeof elem && null !== elem && _io1(elem))); const _io1 = input => "string" === typeof input.name && 1 <= input.name.length && ("string" === typeof input.description && 1 <= input.description.length); const _vo0 = (input, _path, _exceptionable = true) => [(Array.isArray(input.groups) || _report(_exceptionable, {
+                        path: _path + ".groups",
+                        expected: "(Array<IAutoBeInterfaceGroupApplication.IGroup> & MinItems<1>)",
+                        value: input.groups
+                    })) && ((1 <= input.groups.length || _report(_exceptionable, {
+                        path: _path + ".groups",
+                        expected: "Array<> & MinItems<1>",
+                        value: input.groups
+                    })) && input.groups.map((elem, _index2) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".groups[" + _index2 + "]",
+                        expected: "IAutoBeInterfaceGroupApplication.IGroup",
+                        value: elem
+                    })) && _vo1(elem, _path + ".groups[" + _index2 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".groups[" + _index2 + "]",
+                        expected: "IAutoBeInterfaceGroupApplication.IGroup",
+                        value: elem
+                    })).every(flag => flag)) || _report(_exceptionable, {
+                        path: _path + ".groups",
+                        expected: "(Array<IAutoBeInterfaceGroupApplication.IGroup> & MinItems<1>)",
+                        value: input.groups
+                    })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.name && (1 <= input.name.length || _report(_exceptionable, {
+                        path: _path + ".name",
+                        expected: "string & MinLength<1>",
+                        value: input.name
+                    })) || _report(_exceptionable, {
+                        path: _path + ".name",
+                        expected: "(string & MinLength<1>)",
+                        value: input.name
+                    }), "string" === typeof input.description && (1 <= input.description.length || _report(_exceptionable, {
+                        path: _path + ".description",
+                        expected: "string & MinLength<1>",
+                        value: input.description
+                    })) || _report(_exceptionable, {
+                        path: _path + ".description",
+                        expected: "(string & MinLength<1>)",
+                        value: input.description
+                    })].every(flag => flag); const __is = input => "object" === typeof input && null !== input && _io0(input); let errors; let _report; return input => {
+                    if (false === __is(input)) {
+                        errors = [];
+                        _report = __typia_transform__validateReport._validateReport(errors);
+                        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                            path: _path + "",
+                            expected: "IAutoBeInterfaceGroupApplication.IProps",
+                            value: input
+                        })) && _vo0(input, _path + "", true) || _report(true, {
+                            path: _path + "",
+                            expected: "IAutoBeInterfaceGroupApplication.IProps",
+                            value: input
+                        }))(input, "$input", true);
+                        const success = 0 === errors.length;
+                        return success ? {
+                            success,
+                            data: input
+                        } : {
+                            success,
+                            errors,
+                            data: input
+                        };
                     }
-                }
-            },
-            description: "Generate logical groups for organizing API endpoint creation based on\nPrisma schema structure.\n\nDO: Derive groups from Prisma schema organization (namespaces, file\nstructure, table prefixes) rather than arbitrary business domains.\nDO: Create new groups only when existing schema structure cannot adequately\ncover all requirements.",
-            validate: (() => { const _io0 = input => Array.isArray(input.groups) && (1 <= input.groups.length && input.groups.every(elem => "object" === typeof elem && null !== elem && _io1(elem))); const _io1 = input => "string" === typeof input.name && 1 <= input.name.length && ("string" === typeof input.description && 1 <= input.description.length); const _vo0 = (input, _path, _exceptionable = true) => [(Array.isArray(input.groups) || _report(_exceptionable, {
-                    path: _path + ".groups",
-                    expected: "(Array<IAutoBeInterfaceGroupApplication.IGroup> & MinItems<1>)",
-                    value: input.groups
-                })) && ((1 <= input.groups.length || _report(_exceptionable, {
-                    path: _path + ".groups",
-                    expected: "Array<> & MinItems<1>",
-                    value: input.groups
-                })) && input.groups.map((elem, _index2) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
-                    path: _path + ".groups[" + _index2 + "]",
-                    expected: "IAutoBeInterfaceGroupApplication.IGroup",
-                    value: elem
-                })) && _vo1(elem, _path + ".groups[" + _index2 + "]", true && _exceptionable) || _report(_exceptionable, {
-                    path: _path + ".groups[" + _index2 + "]",
-                    expected: "IAutoBeInterfaceGroupApplication.IGroup",
-                    value: elem
-                })).every(flag => flag)) || _report(_exceptionable, {
-                    path: _path + ".groups",
-                    expected: "(Array<IAutoBeInterfaceGroupApplication.IGroup> & MinItems<1>)",
-                    value: input.groups
-                })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.name && (1 <= input.name.length || _report(_exceptionable, {
-                    path: _path + ".name",
-                    expected: "string & MinLength<1>",
-                    value: input.name
-                })) || _report(_exceptionable, {
-                    path: _path + ".name",
-                    expected: "(string & MinLength<1>)",
-                    value: input.name
-                }), "string" === typeof input.description && (1 <= input.description.length || _report(_exceptionable, {
-                    path: _path + ".description",
-                    expected: "string & MinLength<1>",
-                    value: input.description
-                })) || _report(_exceptionable, {
-                    path: _path + ".description",
-                    expected: "(string & MinLength<1>)",
-                    value: input.description
-                })].every(flag => flag); const __is = input => "object" === typeof input && null !== input && _io0(input); let errors; let _report; return input => {
-                if (false === __is(input)) {
-                    errors = [];
-                    _report = __typia_transform__validateReport._validateReport(errors);
-                    ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
-                        path: _path + "",
-                        expected: "IAutoBeInterfaceGroupApplication.IProps",
-                        value: input
-                    })) && _vo0(input, _path + "", true) || _report(true, {
-                        path: _path + "",
-                        expected: "IAutoBeInterfaceGroupApplication.IProps",
-                        value: input
-                    }))(input, "$input", true);
-                    const success = 0 === errors.length;
-                    return success ? {
-                        success,
-                        data: input
-                    } : {
-                        success,
-                        errors,
+                    return {
+                        success: true,
                         data: input
                     };
-                }
-                return {
-                    success: true,
-                    data: input
-                };
-            }; })()
-        }
-    ]
-};
-const chatgpt = {
-    model: "chatgpt",
-    options: {
-        reference: true,
-        strict: false,
-        separate: null
+                }; })()
+            }
+        ]
     },
-    functions: [
-        {
-            name: "makeGroups",
-            parameters: {
-                description: " Properties containing the groups to be created for API\norganization\n\n------------------------------\n\nCurrent Type: {@link IAutoBeInterfaceGroupApplication.IProps}",
-                type: "object",
-                properties: {
-                    groups: {
-                        description: "Array of API endpoint groups for organizing development.\n\nDO: Organize groups around existing Prisma schema structure.\nDO: Provide complete coverage of all entities and requirements without\noverlap.\n\n\n@minItems 1",
-                        type: "array",
-                        items: {
-                            $ref: "#/$defs/IAutoBeInterfaceGroupApplication.IGroup"
+    claude: {
+        model: "claude",
+        options: {
+            reference: true,
+            separate: null
+        },
+        functions: [
+            {
+                name: "makeGroups",
+                parameters: {
+                    description: " Properties containing the groups to be created for API\norganization\n\n------------------------------\n\nCurrent Type: {@link IAutoBeInterfaceGroupApplication.IProps}",
+                    type: "object",
+                    properties: {
+                        groups: {
+                            description: "Array of API endpoint groups for organizing development.\n\nDO: Organize groups around existing Prisma schema structure.\nDO: Provide complete coverage of all entities and requirements without\noverlap.",
+                            type: "array",
+                            items: {
+                                $ref: "#/$defs/IAutoBeInterfaceGroupApplication.IGroup"
+                            },
+                            minItems: 1
+                        }
+                    },
+                    required: [
+                        "groups"
+                    ],
+                    additionalProperties: false,
+                    $defs: {
+                        "IAutoBeInterfaceGroupApplication.IGroup": {
+                            description: "Definition of a logical API endpoint group based on Prisma schema\norganization.\n\n**SCHEMA-BASED GROUP REQUIREMENTS:**\n\nDO: Derive groups from the Prisma schema structure rather than arbitrary\nbusiness domain names.\n\nThis ensures consistency with the underlying data model and prevents\nmisalignment between API organization and database structure.\n\n**Primary Group Sources (in order of priority):**\n\n1. **Prisma Schema Namespaces**: Use namespace names (e.g., `namespace\n   Shopping` \u2192 \"Shopping\")\n2. **Schema File Names**: Derive from file names (e.g., `shopping.prisma` \u2192\n   \"Shopping\")\n3. **Table Prefix Patterns**: Use consistent prefixes (e.g., `shopping_orders`\n   \u2192 \"Shopping\")\n4. **Schema Comments/Annotations**: Follow organizational comments in schema\n\n**Group Creation Guidelines:**\n\n- Each group covers specific Prisma schema entities without overlap\n- Size groups appropriately for manageable endpoint generation cycles\n- Maintain clear boundaries based on schema organization\n- Ensure complete coverage of all database entities and requirements\n- Related database tables within the same schema area are grouped together\n\n**When to Create Schema-Independent Groups:**\n\nOnly create groups that don't correspond to Prisma schema organization\nwhen:\n\n- Requirements include functionality not represented in any schema entity\n- Cross-cutting concerns span multiple schema areas\n- Integration operations don't map to specific database entities\n- System-level functionality requires dedicated API operations\n\n**Naming Standards:**\n\n- Use PascalCase format (e.g., \"Shopping\", \"BBS\", \"UserManagement\")\n- Names directly reflect Prisma schema structure\n- Keep names concise and schema-derived\n- Avoid arbitrary business domain names\n- Maintain consistency with schema organization\n\n**Quality Requirements:**\n\n- Groups collectively cover ALL entities and requirements\n- Each database entity belongs to exactly one group\n- Clear mapping to specific Prisma schema elements\n- Balance group sizes within schema constraints\n- Follow existing schema namespace or file structure patterns",
+                            type: "object",
+                            properties: {
+                                name: {
+                                    description: "Unique identifier name derived from Prisma schema structure.\n\nDO: Correspond to schema namespaces, file names, table prefixes, or\norganizational annotations rather than arbitrary business domain names.",
+                                    type: "string",
+                                    minLength: 1
+                                },
+                                description: {
+                                    description: "Concise description of the group's core purpose.\n\n**Requirements:**\n- Keep it brief and focused (50-200 characters)\n- State the main purpose and key entities\n- Avoid detailed explanations or mappings\n\nExample: \"Handles shopping-related entities and operations\"",
+                                    type: "string",
+                                    minLength: 1
+                                }
+                            },
+                            required: [
+                                "name",
+                                "description"
+                            ]
                         }
                     }
                 },
-                required: [
-                    "groups"
-                ],
-                additionalProperties: false,
-                $defs: {
-                    "IAutoBeInterfaceGroupApplication.IGroup": {
-                        description: "Definition of a logical API endpoint group based on Prisma schema\norganization.\n\n**SCHEMA-BASED GROUP REQUIREMENTS:**\n\nDO: Derive groups from the Prisma schema structure rather than arbitrary\nbusiness domain names.\n\nThis ensures consistency with the underlying data model and prevents\nmisalignment between API organization and database structure.\n\n**Primary Group Sources (in order of priority):**\n\n1. **Prisma Schema Namespaces**: Use namespace names (e.g., `namespace\n   Shopping` \u2192 \"Shopping\")\n2. **Schema File Names**: Derive from file names (e.g., `shopping.prisma` \u2192\n   \"Shopping\")\n3. **Table Prefix Patterns**: Use consistent prefixes (e.g., `shopping_orders`\n   \u2192 \"Shopping\")\n4. **Schema Comments/Annotations**: Follow organizational comments in schema\n\n**Group Creation Guidelines:**\n\n- Each group covers specific Prisma schema entities without overlap\n- Size groups appropriately for manageable endpoint generation cycles\n- Maintain clear boundaries based on schema organization\n- Ensure complete coverage of all database entities and requirements\n- Related database tables within the same schema area are grouped together\n\n**When to Create Schema-Independent Groups:**\n\nOnly create groups that don't correspond to Prisma schema organization\nwhen:\n\n- Requirements include functionality not represented in any schema entity\n- Cross-cutting concerns span multiple schema areas\n- Integration operations don't map to specific database entities\n- System-level functionality requires dedicated API operations\n\n**Naming Standards:**\n\n- Use PascalCase format (e.g., \"Shopping\", \"BBS\", \"UserManagement\")\n- Names directly reflect Prisma schema structure\n- Keep names concise and schema-derived\n- Avoid arbitrary business domain names\n- Maintain consistency with schema organization\n\n**Quality Requirements:**\n\n- Groups collectively cover ALL entities and requirements\n- Each database entity belongs to exactly one group\n- Clear mapping to specific Prisma schema elements\n- Balance group sizes within schema constraints\n- Follow existing schema namespace or file structure patterns",
-                        type: "object",
-                        properties: {
-                            name: {
-                                description: "Unique identifier name derived from Prisma schema structure.\n\nDO: Correspond to schema namespaces, file names, table prefixes, or\norganizational annotations rather than arbitrary business domain names.\n\n\n@minLength 1",
-                                type: "string"
-                            },
-                            description: {
-                                description: "Concise description of the group's core purpose.\n\n**Requirements:**\n- Keep it brief and focused (50-200 characters)\n- State the main purpose and key entities\n- Avoid detailed explanations or mappings\n\nExample: \"Handles shopping-related entities and operations\"\n\n\n@minLength 1",
-                                type: "string"
-                            }
-                        },
-                        required: [
-                            "name",
-                            "description"
-                        ]
+                description: "Generate logical groups for organizing API endpoint creation based on\nPrisma schema structure.\n\nDO: Derive groups from Prisma schema organization (namespaces, file\nstructure, table prefixes) rather than arbitrary business domains.\nDO: Create new groups only when existing schema structure cannot adequately\ncover all requirements.",
+                validate: (() => { const _io0 = input => Array.isArray(input.groups) && (1 <= input.groups.length && input.groups.every(elem => "object" === typeof elem && null !== elem && _io1(elem))); const _io1 = input => "string" === typeof input.name && 1 <= input.name.length && ("string" === typeof input.description && 1 <= input.description.length); const _vo0 = (input, _path, _exceptionable = true) => [(Array.isArray(input.groups) || _report(_exceptionable, {
+                        path: _path + ".groups",
+                        expected: "(Array<IAutoBeInterfaceGroupApplication.IGroup> & MinItems<1>)",
+                        value: input.groups
+                    })) && ((1 <= input.groups.length || _report(_exceptionable, {
+                        path: _path + ".groups",
+                        expected: "Array<> & MinItems<1>",
+                        value: input.groups
+                    })) && input.groups.map((elem, _index2) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".groups[" + _index2 + "]",
+                        expected: "IAutoBeInterfaceGroupApplication.IGroup",
+                        value: elem
+                    })) && _vo1(elem, _path + ".groups[" + _index2 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".groups[" + _index2 + "]",
+                        expected: "IAutoBeInterfaceGroupApplication.IGroup",
+                        value: elem
+                    })).every(flag => flag)) || _report(_exceptionable, {
+                        path: _path + ".groups",
+                        expected: "(Array<IAutoBeInterfaceGroupApplication.IGroup> & MinItems<1>)",
+                        value: input.groups
+                    })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.name && (1 <= input.name.length || _report(_exceptionable, {
+                        path: _path + ".name",
+                        expected: "string & MinLength<1>",
+                        value: input.name
+                    })) || _report(_exceptionable, {
+                        path: _path + ".name",
+                        expected: "(string & MinLength<1>)",
+                        value: input.name
+                    }), "string" === typeof input.description && (1 <= input.description.length || _report(_exceptionable, {
+                        path: _path + ".description",
+                        expected: "string & MinLength<1>",
+                        value: input.description
+                    })) || _report(_exceptionable, {
+                        path: _path + ".description",
+                        expected: "(string & MinLength<1>)",
+                        value: input.description
+                    })].every(flag => flag); const __is = input => "object" === typeof input && null !== input && _io0(input); let errors; let _report; return input => {
+                    if (false === __is(input)) {
+                        errors = [];
+                        _report = __typia_transform__validateReport._validateReport(errors);
+                        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                            path: _path + "",
+                            expected: "IAutoBeInterfaceGroupApplication.IProps",
+                            value: input
+                        })) && _vo0(input, _path + "", true) || _report(true, {
+                            path: _path + "",
+                            expected: "IAutoBeInterfaceGroupApplication.IProps",
+                            value: input
+                        }))(input, "$input", true);
+                        const success = 0 === errors.length;
+                        return success ? {
+                            success,
+                            data: input
+                        } : {
+                            success,
+                            errors,
+                            data: input
+                        };
                     }
-                }
-            },
-            description: "Generate logical groups for organizing API endpoint creation based on\nPrisma schema structure.\n\nDO: Derive groups from Prisma schema organization (namespaces, file\nstructure, table prefixes) rather than arbitrary business domains.\nDO: Create new groups only when existing schema structure cannot adequately\ncover all requirements.",
-            validate: (() => { const _io0 = input => Array.isArray(input.groups) && (1 <= input.groups.length && input.groups.every(elem => "object" === typeof elem && null !== elem && _io1(elem))); const _io1 = input => "string" === typeof input.name && 1 <= input.name.length && ("string" === typeof input.description && 1 <= input.description.length); const _vo0 = (input, _path, _exceptionable = true) => [(Array.isArray(input.groups) || _report(_exceptionable, {
-                    path: _path + ".groups",
-                    expected: "(Array<IAutoBeInterfaceGroupApplication.IGroup> & MinItems<1>)",
-                    value: input.groups
-                })) && ((1 <= input.groups.length || _report(_exceptionable, {
-                    path: _path + ".groups",
-                    expected: "Array<> & MinItems<1>",
-                    value: input.groups
-                })) && input.groups.map((elem, _index2) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
-                    path: _path + ".groups[" + _index2 + "]",
-                    expected: "IAutoBeInterfaceGroupApplication.IGroup",
-                    value: elem
-                })) && _vo1(elem, _path + ".groups[" + _index2 + "]", true && _exceptionable) || _report(_exceptionable, {
-                    path: _path + ".groups[" + _index2 + "]",
-                    expected: "IAutoBeInterfaceGroupApplication.IGroup",
-                    value: elem
-                })).every(flag => flag)) || _report(_exceptionable, {
-                    path: _path + ".groups",
-                    expected: "(Array<IAutoBeInterfaceGroupApplication.IGroup> & MinItems<1>)",
-                    value: input.groups
-                })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.name && (1 <= input.name.length || _report(_exceptionable, {
-                    path: _path + ".name",
-                    expected: "string & MinLength<1>",
-                    value: input.name
-                })) || _report(_exceptionable, {
-                    path: _path + ".name",
-                    expected: "(string & MinLength<1>)",
-                    value: input.name
-                }), "string" === typeof input.description && (1 <= input.description.length || _report(_exceptionable, {
-                    path: _path + ".description",
-                    expected: "string & MinLength<1>",
-                    value: input.description
-                })) || _report(_exceptionable, {
-                    path: _path + ".description",
-                    expected: "(string & MinLength<1>)",
-                    value: input.description
-                })].every(flag => flag); const __is = input => "object" === typeof input && null !== input && _io0(input); let errors; let _report; return input => {
-                if (false === __is(input)) {
-                    errors = [];
-                    _report = __typia_transform__validateReport._validateReport(errors);
-                    ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
-                        path: _path + "",
-                        expected: "IAutoBeInterfaceGroupApplication.IProps",
-                        value: input
-                    })) && _vo0(input, _path + "", true) || _report(true, {
-                        path: _path + "",
-                        expected: "IAutoBeInterfaceGroupApplication.IProps",
-                        value: input
-                    }))(input, "$input", true);
-                    const success = 0 === errors.length;
-                    return success ? {
-                        success,
+                    return {
+                        success: true,
                         data: input
-                    } : {
-                        success,
-                        errors,
+                    };
+                }; })()
+            }
+        ]
+    },
+    gemini: {
+        model: "gemini",
+        options: {
+            reference: true,
+            separate: null
+        },
+        functions: [
+            {
+                name: "makeGroups",
+                parameters: {
+                    description: " Properties containing the groups to be created for API\norganization\n\n------------------------------\n\nCurrent Type: {@link IAutoBeInterfaceGroupApplication.IProps}",
+                    type: "object",
+                    properties: {
+                        groups: {
+                            description: "Array of API endpoint groups for organizing development.\n\nDO: Organize groups around existing Prisma schema structure.\nDO: Provide complete coverage of all entities and requirements without\noverlap.",
+                            type: "array",
+                            items: {
+                                $ref: "#/$defs/IAutoBeInterfaceGroupApplication.IGroup"
+                            },
+                            minItems: 1
+                        }
+                    },
+                    required: [
+                        "groups"
+                    ],
+                    additionalProperties: false,
+                    $defs: {
+                        "IAutoBeInterfaceGroupApplication.IGroup": {
+                            description: "Definition of a logical API endpoint group based on Prisma schema\norganization.\n\n**SCHEMA-BASED GROUP REQUIREMENTS:**\n\nDO: Derive groups from the Prisma schema structure rather than arbitrary\nbusiness domain names.\n\nThis ensures consistency with the underlying data model and prevents\nmisalignment between API organization and database structure.\n\n**Primary Group Sources (in order of priority):**\n\n1. **Prisma Schema Namespaces**: Use namespace names (e.g., `namespace\n   Shopping` \u2192 \"Shopping\")\n2. **Schema File Names**: Derive from file names (e.g., `shopping.prisma` \u2192\n   \"Shopping\")\n3. **Table Prefix Patterns**: Use consistent prefixes (e.g., `shopping_orders`\n   \u2192 \"Shopping\")\n4. **Schema Comments/Annotations**: Follow organizational comments in schema\n\n**Group Creation Guidelines:**\n\n- Each group covers specific Prisma schema entities without overlap\n- Size groups appropriately for manageable endpoint generation cycles\n- Maintain clear boundaries based on schema organization\n- Ensure complete coverage of all database entities and requirements\n- Related database tables within the same schema area are grouped together\n\n**When to Create Schema-Independent Groups:**\n\nOnly create groups that don't correspond to Prisma schema organization\nwhen:\n\n- Requirements include functionality not represented in any schema entity\n- Cross-cutting concerns span multiple schema areas\n- Integration operations don't map to specific database entities\n- System-level functionality requires dedicated API operations\n\n**Naming Standards:**\n\n- Use PascalCase format (e.g., \"Shopping\", \"BBS\", \"UserManagement\")\n- Names directly reflect Prisma schema structure\n- Keep names concise and schema-derived\n- Avoid arbitrary business domain names\n- Maintain consistency with schema organization\n\n**Quality Requirements:**\n\n- Groups collectively cover ALL entities and requirements\n- Each database entity belongs to exactly one group\n- Clear mapping to specific Prisma schema elements\n- Balance group sizes within schema constraints\n- Follow existing schema namespace or file structure patterns",
+                            type: "object",
+                            properties: {
+                                name: {
+                                    description: "Unique identifier name derived from Prisma schema structure.\n\nDO: Correspond to schema namespaces, file names, table prefixes, or\norganizational annotations rather than arbitrary business domain names.",
+                                    type: "string",
+                                    minLength: 1
+                                },
+                                description: {
+                                    description: "Concise description of the group's core purpose.\n\n**Requirements:**\n- Keep it brief and focused (50-200 characters)\n- State the main purpose and key entities\n- Avoid detailed explanations or mappings\n\nExample: \"Handles shopping-related entities and operations\"",
+                                    type: "string",
+                                    minLength: 1
+                                }
+                            },
+                            required: [
+                                "name",
+                                "description"
+                            ]
+                        }
+                    }
+                },
+                description: "Generate logical groups for organizing API endpoint creation based on\nPrisma schema structure.\n\nDO: Derive groups from Prisma schema organization (namespaces, file\nstructure, table prefixes) rather than arbitrary business domains.\nDO: Create new groups only when existing schema structure cannot adequately\ncover all requirements.",
+                validate: (() => { const _io0 = input => Array.isArray(input.groups) && (1 <= input.groups.length && input.groups.every(elem => "object" === typeof elem && null !== elem && _io1(elem))); const _io1 = input => "string" === typeof input.name && 1 <= input.name.length && ("string" === typeof input.description && 1 <= input.description.length); const _vo0 = (input, _path, _exceptionable = true) => [(Array.isArray(input.groups) || _report(_exceptionable, {
+                        path: _path + ".groups",
+                        expected: "(Array<IAutoBeInterfaceGroupApplication.IGroup> & MinItems<1>)",
+                        value: input.groups
+                    })) && ((1 <= input.groups.length || _report(_exceptionable, {
+                        path: _path + ".groups",
+                        expected: "Array<> & MinItems<1>",
+                        value: input.groups
+                    })) && input.groups.map((elem, _index2) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".groups[" + _index2 + "]",
+                        expected: "IAutoBeInterfaceGroupApplication.IGroup",
+                        value: elem
+                    })) && _vo1(elem, _path + ".groups[" + _index2 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".groups[" + _index2 + "]",
+                        expected: "IAutoBeInterfaceGroupApplication.IGroup",
+                        value: elem
+                    })).every(flag => flag)) || _report(_exceptionable, {
+                        path: _path + ".groups",
+                        expected: "(Array<IAutoBeInterfaceGroupApplication.IGroup> & MinItems<1>)",
+                        value: input.groups
+                    })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.name && (1 <= input.name.length || _report(_exceptionable, {
+                        path: _path + ".name",
+                        expected: "string & MinLength<1>",
+                        value: input.name
+                    })) || _report(_exceptionable, {
+                        path: _path + ".name",
+                        expected: "(string & MinLength<1>)",
+                        value: input.name
+                    }), "string" === typeof input.description && (1 <= input.description.length || _report(_exceptionable, {
+                        path: _path + ".description",
+                        expected: "string & MinLength<1>",
+                        value: input.description
+                    })) || _report(_exceptionable, {
+                        path: _path + ".description",
+                        expected: "(string & MinLength<1>)",
+                        value: input.description
+                    })].every(flag => flag); const __is = input => "object" === typeof input && null !== input && _io0(input); let errors; let _report; return input => {
+                    if (false === __is(input)) {
+                        errors = [];
+                        _report = __typia_transform__validateReport._validateReport(errors);
+                        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                            path: _path + "",
+                            expected: "IAutoBeInterfaceGroupApplication.IProps",
+                            value: input
+                        })) && _vo0(input, _path + "", true) || _report(true, {
+                            path: _path + "",
+                            expected: "IAutoBeInterfaceGroupApplication.IProps",
+                            value: input
+                        }))(input, "$input", true);
+                        const success = 0 === errors.length;
+                        return success ? {
+                            success,
+                            data: input
+                        } : {
+                            success,
+                            errors,
+                            data: input
+                        };
+                    }
+                    return {
+                        success: true,
                         data: input
                     };
-                }
-                return {
-                    success: true,
-                    data: input
-                };
-            }; })()
-        }
-    ]
-};
-const collection = {
-    chatgpt,
-    claude,
-    llama: claude,
-    deepseek: claude,
-    "3.1": claude,
+                }; })()
+            }
+        ]
+    },
 };
 //# sourceMappingURL=orchestrateInterfaceGroups.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"orchestrateInterfaceGroups.js","sourceRoot":"","sources":["../../../src/orchestrate/interface/orchestrateInterfaceGroups.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYA,gEAsCC;;AA9CD,kDAA0B;AAC1B,+BAA0B;AAG1B,uEAAoE;AACpE,mGAAgG;AAGhG,SAAsB,0BAA0B,CAG9C,GAAyB,EACzB,KAGC;;;QAED,MAAM,KAAK,GAAS,IAAI,IAAI,EAAE,CAAC;QAC/B,MAAM,OAAO,GAA6D;YACxE,KAAK,EAAE,IAAI;SACZ,CAAC;QACF,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,GAAG,CAAC,UAAU,CAAC;YAClD,MAAM,EAAE,gBAAgB;YACxB,SAAS,EAAE,IAAA,mEAAgC,EAAC;gBAC1C,KAAK,EAAE,GAAG,CAAC,KAAK,EAAE;gBAClB,WAAW,EAAE,KAAK,CAAC,WAAW;aAC/B,CAAC;YACF,UAAU,EAAE,gBAAgB,CAAC;gBAC3B,KAAK,EAAE,GAAG,CAAC,KAAK;gBAChB,KAAK,EAAE,CAAC,IAAI,EAAE,EAAE;oBACd,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;gBACvB,CAAC;aACF,CAAC;YACF,mBAAmB,EAAE,IAAI;YACzB,OAAO,EAAE,MAAA,KAAK,CAAC,OAAO,mCAAI,6CAA6C;SACxE,CAAC,CAAC;QACH,IAAI,OAAO,CAAC,KAAK,KAAK,IAAI;YAAE,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC,CAAC,cAAc;QACzF,OAAO;YACL,IAAI,EAAE,gBAAgB;YACtB,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,KAAK,CAAC,WAAW,EAAE;YAC/B,MAAM,EAAE,OAAO,CAAC,KAAK,CAAC,MAAM;YAC5B,MAAM;YACN,UAAU;YACV,IAAI,EAAE,MAAA,MAAA,GAAG,CAAC,KAAK,EAAE,CAAC,OAAO,0CAAE,IAAI,mCAAI,CAAC;SACD,CAAC;IACxC,CAAC;CAAA;AAED,SAAS,gBAAgB,CAAiC,KAGzD;IACC,IAAA,qCAAiB,EAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAE/B,MAAM,WAAW,GAA2B,UAAU,CACpD,KAAK,CAAC,KAAK,CACwD,CAAC;IACtE,OAAO;QACL,QAAQ,EAAE,OAAO;QACjB,IAAI,EAAE,WAAW;QACjB,WAAW;QACX,OAAO,EAAE;YACP,UAAU,EAAE,CAAC,IAAI,EAAE,EAAE;gBACnB,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YACpB,CAAC;SACyC;KAC7C,CAAC;AACJ,CAAC;AAED,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGT,CAAC;AACJ,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGV,CAAC;AACJ,MAAM,UAAU,GAAG;IACjB,OAAO;IACP,MAAM;IACN,KAAK,EAAE,MAAM;IACb,QAAQ,EAAE,MAAM;IAChB,KAAK,EAAE,MAAM;CACd,CAAC"}
+{"version":3,"file":"orchestrateInterfaceGroups.js","sourceRoot":"","sources":["../../../src/orchestrate/interface/orchestrateInterfaceGroups.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYA,gEAsCC;;AA9CD,kDAA0B;AAC1B,+BAA0B;AAG1B,uEAAoE;AACpE,mGAAgG;AAGhG,SAAsB,0BAA0B,CAG9C,GAAyB,EACzB,KAGC;;;QAED,MAAM,KAAK,GAAS,IAAI,IAAI,EAAE,CAAC;QAC/B,MAAM,OAAO,GAA6D;YACxE,KAAK,EAAE,IAAI;SACZ,CAAC;QACF,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,GAAG,CAAC,UAAU,CAAC;YAClD,MAAM,EAAE,gBAAgB;YACxB,SAAS,EAAE,IAAA,mEAAgC,EAAC;gBAC1C,KAAK,EAAE,GAAG,CAAC,KAAK,EAAE;gBAClB,WAAW,EAAE,KAAK,CAAC,WAAW;aAC/B,CAAC;YACF,UAAU,EAAE,gBAAgB,CAAC;gBAC3B,KAAK,EAAE,GAAG,CAAC,KAAK;gBAChB,KAAK,EAAE,CAAC,IAAI,EAAE,EAAE;oBACd,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;gBACvB,CAAC;aACF,CAAC;YACF,mBAAmB,EAAE,IAAI;YACzB,OAAO,EAAE,MAAA,KAAK,CAAC,OAAO,mCAAI,6CAA6C;SACxE,CAAC,CAAC;QACH,IAAI,OAAO,CAAC,KAAK,KAAK,IAAI;YAAE,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC,CAAC,cAAc;QACzF,OAAO;YACL,IAAI,EAAE,gBAAgB;YACtB,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,KAAK,CAAC,WAAW,EAAE;YAC/B,MAAM,EAAE,OAAO,CAAC,KAAK,CAAC,MAAM;YAC5B,MAAM;YACN,UAAU;YACV,IAAI,EAAE,MAAA,MAAA,GAAG,CAAC,KAAK,EAAE,CAAC,OAAO,0CAAE,IAAI,mCAAI,CAAC;SACD,CAAC;IACxC,CAAC;CAAA;AAED,SAAS,gBAAgB,CAAiC,KAGzD;IACC,IAAA,qCAAiB,EAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAE/B,MAAM,WAAW,GAA2B,UAAU,CACpD,KAAK,CAAC,KAAK,KAAK,SAAS;QACvB,CAAC,CAAC,SAAS;QACX,CAAC,CAAC,KAAK,CAAC,KAAK,KAAK,QAAQ;YACxB,CAAC,CAAC,QAAQ;YACV,CAAC,CAAC,QAAQ,CACqD,CAAC;IACtE,OAAO;QACL,QAAQ,EAAE,OAAO;QACjB,IAAI,EAAE,WAAW;QACjB,WAAW;QACX,OAAO,EAAE;YACP,UAAU,EAAE,CAAC,IAAI,EAAE,EAAE;gBACnB,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YACpB,CAAC;SACyC;KAC7C,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,GAAG;IACjB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAGJ;IACH,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAGH;IACH,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAGH;CACJ,CAAC"}