@autobe/agent 0.25.7 → 0.26.0

package/lib/orchestrate/analyze/orchestrateAnalyzeScenario.js

@@ -67,8 +67,8 @@ const orchestrateAnalyzeScenario = (ctx) => __awaiter(void 0, void 0, void 0, fu
         histories: (0, transformAnalyzeScenarioHistories_1.transformAnalyzeSceHistories)(ctx),
         enforceFunctionCall: false,
         message: utils_1.StringUtil.trim `
-      Design a complete list of documents and user roles for this project.
-      Define user roles that can authenticate via API and create appropriate documentation files.
+      Design a complete list of documents and user actors for this project.
+      Define user actors that can authenticate via API and create appropriate documentation files.
       You must respect the number of documents specified by the user.
       Note that the user's locale is in ${ctx.locale}.
     `,
@@ -84,7 +84,7 @@ const orchestrateAnalyzeScenario = (ctx) => __awaiter(void 0, void 0, void 0, fu
         id: (0, uuid_1.v7)(),
         prefix: pointer.value.prefix,
         language: pointer.value.language,
-        roles: pointer.value.roles,
+        actors: pointer.value.actors,
         files: pointer.value.files,
         tokenUsage,
         step: ((_c = (_b = ctx.state().analyze) === null || _b === void 0 ? void 0 : _b.step) !== null && _c !== void 0 ? _c : -1) + 1,
@@ -116,7 +116,7 @@ const claude = {
         {
             name: "compose",
             parameters: {
-                description: " Prefix, roles, and files\n\n------------------------------\n\nCurrent Type: {@link IAutoBeAnalyzeScenarioApplication.IProps}",
+                description: " Prefix, actors, and files\n\n------------------------------\n\nCurrent Type: {@link IAutoBeAnalyzeScenarioApplication.IProps}",
                 type: "object",
                 properties: {
                     reason: {
@@ -128,11 +128,11 @@ const claude = {
                         type: "string",
                         pattern: "^[a-z][a-zA-Z0-9]*$"
                     },
-                    roles: {
-                        description: "Roles to be assigned for the project",
+                    actors: {
+                        description: "Actors to be assigned for the project",
                         type: "array",
                         items: {
-                            $ref: "#/$defs/AutoBeAnalyzeRole"
+                            $ref: "#/$defs/AutoBeAnalyzeActor"
                         }
                     },
                     language: {
@@ -144,7 +144,7 @@ const claude = {
                         type: "number"
                     },
                     files: {
-                        description: "# Document files to be generated\n\nFile name must be English and it must contain the numbering and prefix.\n\nThese files represent business documentation that may include:\n\n- Business requirements and functional specifications in natural language\n- User journey mapping and use case scenarios\n- Business rules and workflow definitions\n- Service overview and business model description\n- User roles and permission requirements (described in natural language)\n- Business logic and validation rules\n- DO NOT: Include database schemas, ERD, or API specifications\n- DO: Write all requirements in natural language for clarity\n\nGenerate files based on actual requirements gathered from conversation.\nDo not create unnecessary documentation - only generate what is needed to\nproperly define the business requirements and system specifications.\n\n# Page Length Rules\n\nThe number of documents must match the user's request, excluding the\ntable of contents. For example, if the user requests 3 pages, a total of\n4 documents should be generated, including the table of contents. If the\nuser does not specify a number, generate a sufficient number of documents\nto adequately support the service.",
+                        description: "# Document files to be generated\n\nFile name must be English and it must contain the numbering and prefix.\n\nThese files represent business documentation that may include:\n\n- Business requirements and functional specifications in natural language\n- User journey mapping and use case scenarios\n- Business rules and workflow definitions\n- Service overview and business model description\n- User actors and permission requirements (described in natural language)\n- Business logic and validation rules\n- DO NOT: Include database schemas, ERD, or API specifications\n- DO: Write all requirements in natural language for clarity\n\nGenerate files based on actual requirements gathered from conversation.\nDo not create unnecessary documentation - only generate what is needed to\nproperly define the business requirements and system specifications.\n\n# Page Length Rules\n\nThe number of documents must match the user's request, excluding the\ntable of contents. For example, if the user requests 3 pages, a total of\n4 documents should be generated, including the table of contents. If the\nuser does not specify a number, generate a sufficient number of documents\nto adequately support the service.",
                         type: "array",
                         items: {
                             $ref: "#/$defs/AutoBeAnalyzeFile.Scenario"
@@ -155,28 +155,24 @@ const claude = {
                 required: [
                     "reason",
                     "prefix",
-                    "roles",
+                    "actors",
                     "page",
                     "files"
                 ],
                 additionalProperties: false,
                 $defs: {
-                    AutoBeAnalyzeRole: {
-                        description: "Interface representing a user role definition in the requirements analysis\nphase.\n\nThis interface defines authenticated user roles that will be used throughout\nthe application's authentication and authorization system. Each role\nrepresents a distinct type of user who can register, authenticate, and\ninteract with the system based on their specific permissions and\ncapabilities.\n\nThe roles defined here serve as the foundation for generating:\n\n- Prisma schema models for user authentication tables\n- API endpoint access control decorators\n- Role-based authorization logic in the business layer\n- Test scenarios for different user permission levels",
+                    AutoBeAnalyzeActor: {
+                        description: "Interface representing a user actor definition in the requirements analysis\nphase.\n\nThis interface defines authenticated user actors that will be used throughout\nthe application's authentication and authorization system. Each actor\nrepresents a distinct type of user who can register, authenticate, and\ninteract with the system based on their specific permissions and\ncapabilities.\n\nThe actors defined here serve as the foundation for generating:\n\n- Prisma schema models for user authentication tables\n- API endpoint access control decorators\n- Actor-based authorization logic in the business layer\n- Test scenarios for different user permission levels",
                         type: "object",
                         properties: {
                             name: {
-                                description: "Unique identifier for the user role.\n\nThis name will be used as a reference throughout the generated codebase,\nincluding Prisma schema model names, authorization decorator parameters,\nand API documentation.\n\nMUST use camelCase naming convention.",
+                                description: "Unique identifier for the user actor.\n\nThis name will be used as a reference throughout the generated codebase,\nincluding Prisma schema model names, authorization decorator parameters,\nand API documentation.\n\nMUST use camelCase naming convention.",
                                 type: "string",
                                 pattern: "^[a-z][a-zA-Z0-9]*$",
                                 minLength: 1
                             },
-                            description: {
-                                description: "Human-readable description of the role's permissions and capabilities.\n\nThis description helps the AI agents understand the business context and\naccess requirements for each role, guiding the generation of appropriate\nauthorization rules and API endpoint restrictions.",
-                                type: "string"
-                            },
                             kind: {
-                                description: "Role category classification for system-wide permission hierarchy.\n\nThis property categorizes roles into three fundamental permission levels,\nestablishing a clear hierarchy for authorization decisions throughout the\napplication. The kind determines baseline access patterns and security\nboundaries:\n\n- \"guest\": Unauthenticated users or those with minimal permissions. Typically\n  limited to public resources and registration/login endpoints.\n- \"member\": Authenticated users with standard access permissions. Can access\n  personal resources and participate in core application features.\n- \"admin\": System administrators with elevated permissions. Can manage other\n  users, access administrative functions, and modify system-wide settings.",
+                                description: "Actor category classification for system-wide permission hierarchy.\n\nThis property categorizes actors into three fundamental permission levels,\nestablishing a clear hierarchy for authorization decisions throughout the\napplication. The kind determines baseline access patterns and security\nboundaries:\n\n- \"guest\": Unauthenticated users or those with minimal permissions. Typically\n  limited to public resources and registration/login endpoints.\n- \"member\": Authenticated users with standard access permissions. Can access\n  personal resources and participate in core application features.\n- \"admin\": System administrators with elevated permissions. Can manage other\n  users, access administrative functions, and modify system-wide settings.",
                                 oneOf: [
                                     {
                                         "const": "guest"
@@ -188,12 +184,16 @@ const claude = {
                                         "const": "admin"
                                     }
                                 ]
+                            },
+                            description: {
+                                description: "Human-readable description of the actor's permissions and capabilities.\n\nThis description helps the AI agents understand the business context and\naccess requirements for each actor, guiding the generation of appropriate\nauthorization rules and API endpoint restrictions.",
+                                type: "string"
                             }
                         },
                         required: [
                             "name",
-                            "description",
-                            "kind"
+                            "kind",
+                            "description"
                         ]
                     },
                     "AutoBeAnalyzeFile.Scenario": {
@@ -256,8 +256,8 @@ const claude = {
                     }
                 }
             },
-            description: "Compose project structure with roles and files.\n\nDesign a list of roles and initial documents that you need to create for\nthat requirement. Roles define team member responsibilities, while files\ndefine the documentation structure. These are managed separately. If you\ndetermine from the conversation that the user's requirements have not been\nfully gathered, you must stop the analysis and continue collecting the\nremaining requirements. In this case, you do not need to generate any files\nor roles. Simply pass an empty array to `input.files` and `input.roles`.",
-            validate: (() => { const _io0 = input => "string" === typeof input.reason && ("string" === typeof input.prefix && RegExp("^[a-z][a-zA-Z0-9]*$").test(input.prefix)) && (Array.isArray(input.roles) && input.roles.every(elem => "object" === typeof elem && null !== elem && _io1(elem))) && (undefined === input.language || "string" === typeof input.language) && "number" === typeof input.page && (Array.isArray(input.files) && (1 <= input.files.length && input.files.every(elem => "object" === typeof elem && null !== elem && _io2(elem)))); const _io1 = input => "string" === typeof input.name && (RegExp("^[a-z][a-zA-Z0-9]*$").test(input.name) && 1 <= input.name.length) && "string" === typeof input.description && ("guest" === input.kind || "member" === input.kind || "admin" === input.kind); const _io2 = input => "string" === typeof input.reason && ("string" === typeof input.filename && RegExp(/(.*)\.md$/).test(input.filename)) && (undefined === input.documentType || "string" === typeof input.documentType) && (undefined === input.outline || Array.isArray(input.outline) && input.outline.every(elem => "string" === typeof elem)) && (undefined === input.audience || "string" === typeof input.audience) && (undefined === input.keyQuestions || Array.isArray(input.keyQuestions) && input.keyQuestions.every(elem => "string" === typeof elem)) && (undefined === input.detailLevel || "string" === typeof input.detailLevel) && (undefined === input.relatedDocuments || Array.isArray(input.relatedDocuments) && input.relatedDocuments.every(elem => "string" === typeof elem)) && (undefined === input.constraints || Array.isArray(input.constraints) && input.constraints.every(elem => "string" === typeof elem)); const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.reason || _report(_exceptionable, {
+            description: "Compose project structure with actors and files.\n\nDesign a list of actors and initial documents that you need to create for\nthat requirement. Actors define user types and their responsibilities, while files\ndefine the documentation structure. These are managed separately. If you\ndetermine from the conversation that the user's requirements have not been\nfully gathered, you must stop the analysis and continue collecting the\nremaining requirements. In this case, you do not need to generate any files\nor actors. Simply pass an empty array to `input.files` and `input.actors`.",
+            validate: (() => { const _io0 = input => "string" === typeof input.reason && ("string" === typeof input.prefix && RegExp("^[a-z][a-zA-Z0-9]*$").test(input.prefix)) && (Array.isArray(input.actors) && input.actors.every(elem => "object" === typeof elem && null !== elem && _io1(elem))) && (undefined === input.language || "string" === typeof input.language) && "number" === typeof input.page && (Array.isArray(input.files) && (1 <= input.files.length && input.files.every(elem => "object" === typeof elem && null !== elem && _io2(elem)))); const _io1 = input => "string" === typeof input.name && (RegExp("^[a-z][a-zA-Z0-9]*$").test(input.name) && 1 <= input.name.length) && ("guest" === input.kind || "member" === input.kind || "admin" === input.kind) && "string" === typeof input.description; const _io2 = input => "string" === typeof input.reason && ("string" === typeof input.filename && RegExp(/(.*)\.md$/).test(input.filename)) && (undefined === input.documentType || "string" === typeof input.documentType) && (undefined === input.outline || Array.isArray(input.outline) && input.outline.every(elem => "string" === typeof elem)) && (undefined === input.audience || "string" === typeof input.audience) && (undefined === input.keyQuestions || Array.isArray(input.keyQuestions) && input.keyQuestions.every(elem => "string" === typeof elem)) && (undefined === input.detailLevel || "string" === typeof input.detailLevel) && (undefined === input.relatedDocuments || Array.isArray(input.relatedDocuments) && input.relatedDocuments.every(elem => "string" === typeof elem)) && (undefined === input.constraints || Array.isArray(input.constraints) && input.constraints.every(elem => "string" === typeof elem)); const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.reason || _report(_exceptionable, {
                     path: _path + ".reason",
                     expected: "string",
                     value: input.reason
@@ -269,22 +269,22 @@ const claude = {
                     path: _path + ".prefix",
                     expected: "(string & CamelCasePattern)",
                     value: input.prefix
-                }), (Array.isArray(input.roles) || _report(_exceptionable, {
-                    path: _path + ".roles",
-                    expected: "Array<AutoBeAnalyzeRole>",
-                    value: input.roles
-                })) && input.roles.map((elem, _index7) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
-                    path: _path + ".roles[" + _index7 + "]",
-                    expected: "AutoBeAnalyzeRole",
+                }), (Array.isArray(input.actors) || _report(_exceptionable, {
+                    path: _path + ".actors",
+                    expected: "Array<AutoBeAnalyzeActor>",
+                    value: input.actors
+                })) && input.actors.map((elem, _index7) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                    path: _path + ".actors[" + _index7 + "]",
+                    expected: "AutoBeAnalyzeActor",
                     value: elem
-                })) && _vo1(elem, _path + ".roles[" + _index7 + "]", true && _exceptionable) || _report(_exceptionable, {
-                    path: _path + ".roles[" + _index7 + "]",
-                    expected: "AutoBeAnalyzeRole",
+                })) && _vo1(elem, _path + ".actors[" + _index7 + "]", true && _exceptionable) || _report(_exceptionable, {
+                    path: _path + ".actors[" + _index7 + "]",
+                    expected: "AutoBeAnalyzeActor",
                     value: elem
                 })).every(flag => flag) || _report(_exceptionable, {
-                    path: _path + ".roles",
-                    expected: "Array<AutoBeAnalyzeRole>",
-                    value: input.roles
+                    path: _path + ".actors",
+                    expected: "Array<AutoBeAnalyzeActor>",
+                    value: input.actors
                 }), undefined === input.language || "string" === typeof input.language || _report(_exceptionable, {
                     path: _path + ".language",
                     expected: "(string | undefined)",
@@ -325,14 +325,14 @@ const claude = {
                     path: _path + ".name",
                     expected: "(string & CamelCasePattern & MinLength<1>)",
                     value: input.name
-                }), "string" === typeof input.description || _report(_exceptionable, {
-                    path: _path + ".description",
-                    expected: "string",
-                    value: input.description
                 }), "guest" === input.kind || "member" === input.kind || "admin" === input.kind || _report(_exceptionable, {
                     path: _path + ".kind",
                     expected: "(\"admin\" | \"guest\" | \"member\")",
                     value: input.kind
+                }), "string" === typeof input.description || _report(_exceptionable, {
+                    path: _path + ".description",
+                    expected: "string",
+                    value: input.description
                 })].every(flag => flag); const _vo2 = (input, _path, _exceptionable = true) => ["string" === typeof input.reason || _report(_exceptionable, {
                     path: _path + ".reason",
                     expected: "string",
@@ -444,7 +444,7 @@ const collection = {
             {
                 name: "compose",
                 parameters: {
-                    description: " Prefix, roles, and files\n\n------------------------------\n\nCurrent Type: {@link IAutoBeAnalyzeScenarioApplication.IProps}",
+                    description: " Prefix, actors, and files\n\n------------------------------\n\nCurrent Type: {@link IAutoBeAnalyzeScenarioApplication.IProps}",
                     type: "object",
                     properties: {
                         reason: {
@@ -455,11 +455,11 @@ const collection = {
                             description: "Prefix for file names and variable names. This will be used for\norganizing documentation files.\n\nDO: Use camelCase naming convention.\n\n\n@pattern ^[a-z][a-zA-Z0-9]*$",
                             type: "string"
                         },
-                        roles: {
-                            description: "Roles to be assigned for the project",
+                        actors: {
+                            description: "Actors to be assigned for the project",
                             type: "array",
                             items: {
-                                $ref: "#/$defs/AutoBeAnalyzeRole"
+                                $ref: "#/$defs/AutoBeAnalyzeActor"
                             }
                         },
                         language: {
@@ -471,7 +471,7 @@ const collection = {
                             type: "number"
                         },
                         files: {
-                            description: "# Document files to be generated\n\nFile name must be English and it must contain the numbering and prefix.\n\nThese files represent business documentation that may include:\n\n- Business requirements and functional specifications in natural language\n- User journey mapping and use case scenarios\n- Business rules and workflow definitions\n- Service overview and business model description\n- User roles and permission requirements (described in natural language)\n- Business logic and validation rules\n- DO NOT: Include database schemas, ERD, or API specifications\n- DO: Write all requirements in natural language for clarity\n\nGenerate files based on actual requirements gathered from conversation.\nDo not create unnecessary documentation - only generate what is needed to\nproperly define the business requirements and system specifications.\n\n# Page Length Rules\n\nThe number of documents must match the user's request, excluding the\ntable of contents. For example, if the user requests 3 pages, a total of\n4 documents should be generated, including the table of contents. If the\nuser does not specify a number, generate a sufficient number of documents\nto adequately support the service.\n\n\n@minItems 1",
+                            description: "# Document files to be generated\n\nFile name must be English and it must contain the numbering and prefix.\n\nThese files represent business documentation that may include:\n\n- Business requirements and functional specifications in natural language\n- User journey mapping and use case scenarios\n- Business rules and workflow definitions\n- Service overview and business model description\n- User actors and permission requirements (described in natural language)\n- Business logic and validation rules\n- DO NOT: Include database schemas, ERD, or API specifications\n- DO: Write all requirements in natural language for clarity\n\nGenerate files based on actual requirements gathered from conversation.\nDo not create unnecessary documentation - only generate what is needed to\nproperly define the business requirements and system specifications.\n\n# Page Length Rules\n\nThe number of documents must match the user's request, excluding the\ntable of contents. For example, if the user requests 3 pages, a total of\n4 documents should be generated, including the table of contents. If the\nuser does not specify a number, generate a sufficient number of documents\nto adequately support the service.\n\n\n@minItems 1",
                             type: "array",
                             items: {
                                 $ref: "#/$defs/AutoBeAnalyzeFile.Scenario"
@@ -481,38 +481,38 @@ const collection = {
                     required: [
                         "reason",
                         "prefix",
-                        "roles",
+                        "actors",
                         "page",
                         "files"
                     ],
                     additionalProperties: false,
                     $defs: {
-                        AutoBeAnalyzeRole: {
-                            description: "Interface representing a user role definition in the requirements analysis\nphase.\n\nThis interface defines authenticated user roles that will be used throughout\nthe application's authentication and authorization system. Each role\nrepresents a distinct type of user who can register, authenticate, and\ninteract with the system based on their specific permissions and\ncapabilities.\n\nThe roles defined here serve as the foundation for generating:\n\n- Prisma schema models for user authentication tables\n- API endpoint access control decorators\n- Role-based authorization logic in the business layer\n- Test scenarios for different user permission levels",
+                        AutoBeAnalyzeActor: {
+                            description: "Interface representing a user actor definition in the requirements analysis\nphase.\n\nThis interface defines authenticated user actors that will be used throughout\nthe application's authentication and authorization system. Each actor\nrepresents a distinct type of user who can register, authenticate, and\ninteract with the system based on their specific permissions and\ncapabilities.\n\nThe actors defined here serve as the foundation for generating:\n\n- Prisma schema models for user authentication tables\n- API endpoint access control decorators\n- Actor-based authorization logic in the business layer\n- Test scenarios for different user permission levels",
                             type: "object",
                             properties: {
                                 name: {
-                                    description: "Unique identifier for the user role.\n\nThis name will be used as a reference throughout the generated codebase,\nincluding Prisma schema model names, authorization decorator parameters,\nand API documentation.\n\nMUST use camelCase naming convention.\n\n\n@minLength 1\n@pattern ^[a-z][a-zA-Z0-9]*$",
-                                    type: "string"
-                                },
-                                description: {
-                                    description: "Human-readable description of the role's permissions and capabilities.\n\nThis description helps the AI agents understand the business context and\naccess requirements for each role, guiding the generation of appropriate\nauthorization rules and API endpoint restrictions.",
+                                    description: "Unique identifier for the user actor.\n\nThis name will be used as a reference throughout the generated codebase,\nincluding Prisma schema model names, authorization decorator parameters,\nand API documentation.\n\nMUST use camelCase naming convention.\n\n\n@minLength 1\n@pattern ^[a-z][a-zA-Z0-9]*$",
                                     type: "string"
                                 },
                                 kind: {
-                                    description: "Role category classification for system-wide permission hierarchy.\n\nThis property categorizes roles into three fundamental permission levels,\nestablishing a clear hierarchy for authorization decisions throughout the\napplication. The kind determines baseline access patterns and security\nboundaries:\n\n- \"guest\": Unauthenticated users or those with minimal permissions. Typically\n  limited to public resources and registration/login endpoints.\n- \"member\": Authenticated users with standard access permissions. Can access\n  personal resources and participate in core application features.\n- \"admin\": System administrators with elevated permissions. Can manage other\n  users, access administrative functions, and modify system-wide settings.",
+                                    description: "Actor category classification for system-wide permission hierarchy.\n\nThis property categorizes actors into three fundamental permission levels,\nestablishing a clear hierarchy for authorization decisions throughout the\napplication. The kind determines baseline access patterns and security\nboundaries:\n\n- \"guest\": Unauthenticated users or those with minimal permissions. Typically\n  limited to public resources and registration/login endpoints.\n- \"member\": Authenticated users with standard access permissions. Can access\n  personal resources and participate in core application features.\n- \"admin\": System administrators with elevated permissions. Can manage other\n  users, access administrative functions, and modify system-wide settings.",
                                     type: "string",
                                     "enum": [
                                         "guest",
                                         "member",
                                         "admin"
                                     ]
+                                },
+                                description: {
+                                    description: "Human-readable description of the actor's permissions and capabilities.\n\nThis description helps the AI agents understand the business context and\naccess requirements for each actor, guiding the generation of appropriate\nauthorization rules and API endpoint restrictions.",
+                                    type: "string"
                                 }
                             },
                             required: [
                                 "name",
-                                "description",
-                                "kind"
+                                "kind",
+                                "description"
                             ]
                         },
                         "AutoBeAnalyzeFile.Scenario": {
@@ -574,8 +574,8 @@ const collection = {
                         }
                     }
                 },
-                description: "Compose project structure with roles and files.\n\nDesign a list of roles and initial documents that you need to create for\nthat requirement. Roles define team member responsibilities, while files\ndefine the documentation structure. These are managed separately. If you\ndetermine from the conversation that the user's requirements have not been\nfully gathered, you must stop the analysis and continue collecting the\nremaining requirements. In this case, you do not need to generate any files\nor roles. Simply pass an empty array to `input.files` and `input.roles`.",
-                validate: (() => { const _io0 = input => "string" === typeof input.reason && ("string" === typeof input.prefix && RegExp("^[a-z][a-zA-Z0-9]*$").test(input.prefix)) && (Array.isArray(input.roles) && input.roles.every(elem => "object" === typeof elem && null !== elem && _io1(elem))) && (undefined === input.language || "string" === typeof input.language) && "number" === typeof input.page && (Array.isArray(input.files) && (1 <= input.files.length && input.files.every(elem => "object" === typeof elem && null !== elem && _io2(elem)))); const _io1 = input => "string" === typeof input.name && (RegExp("^[a-z][a-zA-Z0-9]*$").test(input.name) && 1 <= input.name.length) && "string" === typeof input.description && ("guest" === input.kind || "member" === input.kind || "admin" === input.kind); const _io2 = input => "string" === typeof input.reason && ("string" === typeof input.filename && RegExp(/(.*)\.md$/).test(input.filename)) && (undefined === input.documentType || "string" === typeof input.documentType) && (undefined === input.outline || Array.isArray(input.outline) && input.outline.every(elem => "string" === typeof elem)) && (undefined === input.audience || "string" === typeof input.audience) && (undefined === input.keyQuestions || Array.isArray(input.keyQuestions) && input.keyQuestions.every(elem => "string" === typeof elem)) && (undefined === input.detailLevel || "string" === typeof input.detailLevel) && (undefined === input.relatedDocuments || Array.isArray(input.relatedDocuments) && input.relatedDocuments.every(elem => "string" === typeof elem)) && (undefined === input.constraints || Array.isArray(input.constraints) && input.constraints.every(elem => "string" === typeof elem)); const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.reason || _report(_exceptionable, {
+                description: "Compose project structure with actors and files.\n\nDesign a list of actors and initial documents that you need to create for\nthat requirement. Actors define user types and their responsibilities, while files\ndefine the documentation structure. These are managed separately. If you\ndetermine from the conversation that the user's requirements have not been\nfully gathered, you must stop the analysis and continue collecting the\nremaining requirements. In this case, you do not need to generate any files\nor actors. Simply pass an empty array to `input.files` and `input.actors`.",
+                validate: (() => { const _io0 = input => "string" === typeof input.reason && ("string" === typeof input.prefix && RegExp("^[a-z][a-zA-Z0-9]*$").test(input.prefix)) && (Array.isArray(input.actors) && input.actors.every(elem => "object" === typeof elem && null !== elem && _io1(elem))) && (undefined === input.language || "string" === typeof input.language) && "number" === typeof input.page && (Array.isArray(input.files) && (1 <= input.files.length && input.files.every(elem => "object" === typeof elem && null !== elem && _io2(elem)))); const _io1 = input => "string" === typeof input.name && (RegExp("^[a-z][a-zA-Z0-9]*$").test(input.name) && 1 <= input.name.length) && ("guest" === input.kind || "member" === input.kind || "admin" === input.kind) && "string" === typeof input.description; const _io2 = input => "string" === typeof input.reason && ("string" === typeof input.filename && RegExp(/(.*)\.md$/).test(input.filename)) && (undefined === input.documentType || "string" === typeof input.documentType) && (undefined === input.outline || Array.isArray(input.outline) && input.outline.every(elem => "string" === typeof elem)) && (undefined === input.audience || "string" === typeof input.audience) && (undefined === input.keyQuestions || Array.isArray(input.keyQuestions) && input.keyQuestions.every(elem => "string" === typeof elem)) && (undefined === input.detailLevel || "string" === typeof input.detailLevel) && (undefined === input.relatedDocuments || Array.isArray(input.relatedDocuments) && input.relatedDocuments.every(elem => "string" === typeof elem)) && (undefined === input.constraints || Array.isArray(input.constraints) && input.constraints.every(elem => "string" === typeof elem)); const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.reason || _report(_exceptionable, {
                         path: _path + ".reason",
                         expected: "string",
                         value: input.reason
@@ -587,22 +587,22 @@ const collection = {
                         path: _path + ".prefix",
                         expected: "(string & CamelCasePattern)",
                         value: input.prefix
-                    }), (Array.isArray(input.roles) || _report(_exceptionable, {
-                        path: _path + ".roles",
-                        expected: "Array<AutoBeAnalyzeRole>",
-                        value: input.roles
-                    })) && input.roles.map((elem, _index7) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
-                        path: _path + ".roles[" + _index7 + "]",
-                        expected: "AutoBeAnalyzeRole",
+                    }), (Array.isArray(input.actors) || _report(_exceptionable, {
+                        path: _path + ".actors",
+                        expected: "Array<AutoBeAnalyzeActor>",
+                        value: input.actors
+                    })) && input.actors.map((elem, _index7) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".actors[" + _index7 + "]",
+                        expected: "AutoBeAnalyzeActor",
                         value: elem
-                    })) && _vo1(elem, _path + ".roles[" + _index7 + "]", true && _exceptionable) || _report(_exceptionable, {
-                        path: _path + ".roles[" + _index7 + "]",
-                        expected: "AutoBeAnalyzeRole",
+                    })) && _vo1(elem, _path + ".actors[" + _index7 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".actors[" + _index7 + "]",
+                        expected: "AutoBeAnalyzeActor",
                         value: elem
                     })).every(flag => flag) || _report(_exceptionable, {
-                        path: _path + ".roles",
-                        expected: "Array<AutoBeAnalyzeRole>",
-                        value: input.roles
+                        path: _path + ".actors",
+                        expected: "Array<AutoBeAnalyzeActor>",
+                        value: input.actors
                     }), undefined === input.language || "string" === typeof input.language || _report(_exceptionable, {
                         path: _path + ".language",
                         expected: "(string | undefined)",
@@ -643,14 +643,14 @@ const collection = {
                         path: _path + ".name",
                         expected: "(string & CamelCasePattern & MinLength<1>)",
                         value: input.name
-                    }), "string" === typeof input.description || _report(_exceptionable, {
-                        path: _path + ".description",
-                        expected: "string",
-                        value: input.description
                     }), "guest" === input.kind || "member" === input.kind || "admin" === input.kind || _report(_exceptionable, {
                         path: _path + ".kind",
                         expected: "(\"admin\" | \"guest\" | \"member\")",
                         value: input.kind
+                    }), "string" === typeof input.description || _report(_exceptionable, {
+                        path: _path + ".description",
+                        expected: "string",
+                        value: input.description
                     })].every(flag => flag); const _vo2 = (input, _path, _exceptionable = true) => ["string" === typeof input.reason || _report(_exceptionable, {
                         path: _path + ".reason",
                         expected: "string",

package/lib/orchestrate/analyze/orchestrateAnalyzeScenario.js.map

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

package/lib/orchestrate/analyze/orchestrateAnalyzeWrite.js

@@ -112,7 +112,7 @@ const claude = {
                 type: "object",
                 properties: {
                     plan: {
-                        description: "Step 1 (CoT: Plan Phase) - Document Planning Structure\n\nThe document planning structure that outlines what needs to be written.\n\nThis includes:\n\n- Document title and purpose\n- Table of contents structure\n- Key sections to be covered\n- Relationships with other documents\n- Target audience (backend developers)\n\nThe plan serves as a roadmap for the AI agent to ensure all necessary\ntopics are covered in the documentation process.\n\nExample plan structure:\n\n- Service overview with business model\n- User roles and authentication requirements\n- Functional requirements with EARS format\n- Non-functional requirements\n- Business requirements in natural language\n- User scenarios and use cases",
+                        description: "Step 1 (CoT: Plan Phase) - Document Planning Structure\n\nThe document planning structure that outlines what needs to be written.\n\nThis includes:\n\n- Document title and purpose\n- Table of contents structure\n- Key sections to be covered\n- Relationships with other documents\n- Target audience (backend developers)\n\nThe plan serves as a roadmap for the AI agent to ensure all necessary\ntopics are covered in the documentation process.\n\nExample plan structure:\n\n- Service overview with business model\n- User actors and authentication requirements\n- Functional requirements with EARS format\n- Non-functional requirements\n- Business requirements in natural language\n- User scenarios and use cases",
                         type: "string"
                     },
                     content: {
@@ -183,7 +183,7 @@ const collection = {
                     type: "object",
                     properties: {
                         plan: {
-                            description: "Step 1 (CoT: Plan Phase) - Document Planning Structure\n\nThe document planning structure that outlines what needs to be written.\n\nThis includes:\n\n- Document title and purpose\n- Table of contents structure\n- Key sections to be covered\n- Relationships with other documents\n- Target audience (backend developers)\n\nThe plan serves as a roadmap for the AI agent to ensure all necessary\ntopics are covered in the documentation process.\n\nExample plan structure:\n\n- Service overview with business model\n- User roles and authentication requirements\n- Functional requirements with EARS format\n- Non-functional requirements\n- Business requirements in natural language\n- User scenarios and use cases",
+                            description: "Step 1 (CoT: Plan Phase) - Document Planning Structure\n\nThe document planning structure that outlines what needs to be written.\n\nThis includes:\n\n- Document title and purpose\n- Table of contents structure\n- Key sections to be covered\n- Relationships with other documents\n- Target audience (backend developers)\n\nThe plan serves as a roadmap for the AI agent to ensure all necessary\ntopics are covered in the documentation process.\n\nExample plan structure:\n\n- Service overview with business model\n- User actors and authentication requirements\n- Functional requirements with EARS format\n- Non-functional requirements\n- Business requirements in natural language\n- User scenarios and use cases",
                             type: "string"
                         },
                         content: {

package/lib/orchestrate/analyze/structures/IAutoBeAnalyzeScenarioApplication.d.ts

@@ -1,19 +1,19 @@
-import { AutoBeAnalyzeRole, CamelCasePattern } from "@autobe/interface";
+import { AutoBeAnalyzeActor, CamelCasePattern } from "@autobe/interface";
 import { AutoBeAnalyzeFile } from "@autobe/interface/src/histories/contents/AutoBeAnalyzeFile";
 import { tags } from "typia";
 export interface IAutoBeAnalyzeScenarioApplication {
     /**
-     * Compose project structure with roles and files.
+     * Compose project structure with actors and files.
      *
-     * Design a list of roles and initial documents that you need to create for
-     * that requirement. Roles define team member responsibilities, while files
+     * Design a list of actors and initial documents that you need to create for
+     * that requirement. Actors define user types and their responsibilities, while files
      * define the documentation structure. These are managed separately. If you
      * determine from the conversation that the user's requirements have not been
      * fully gathered, you must stop the analysis and continue collecting the
      * remaining requirements. In this case, you do not need to generate any files
-     * or roles. Simply pass an empty array to `input.files` and `input.roles`.
+     * or actors. Simply pass an empty array to `input.files` and `input.actors`.
      *
-     * @param input Prefix, roles, and files
+     * @param input Prefix, actors, and files
      * @returns
      */
     compose(input: IAutoBeAnalyzeScenarioApplication.IProps): void;
@@ -29,8 +29,8 @@ export declare namespace IAutoBeAnalyzeScenarioApplication {
          * DO: Use camelCase naming convention.
          */
         prefix: string & CamelCasePattern;
-        /** Roles to be assigned for the project */
-        roles: AutoBeAnalyzeRole[];
+        /** Actors to be assigned for the project */
+        actors: AutoBeAnalyzeActor[];
         /**
          * Language for document content. When specified by the user, this takes
          * precedence over the locale setting for determining document language.
@@ -56,7 +56,7 @@ export declare namespace IAutoBeAnalyzeScenarioApplication {
          * - User journey mapping and use case scenarios
          * - Business rules and workflow definitions
          * - Service overview and business model description
-         * - User roles and permission requirements (described in natural language)
+         * - User actors and permission requirements (described in natural language)
          * - Business logic and validation rules
          * - DO NOT: Include database schemas, ERD, or API specifications
          * - DO: Write all requirements in natural language for clarity

package/lib/orchestrate/analyze/structures/IAutoBeAnalyzeWriteApplication.d.ts

@@ -33,7 +33,7 @@ export declare namespace IAutoBeAnalyzeWriteApplication {
          * Example plan structure:
          *
          * - Service overview with business model
-         * - User roles and authentication requirements
+         * - User actors and authentication requirements
          * - Functional requirements with EARS format
          * - Non-functional requirements
          * - Business requirements in natural language