@autobe/agent 0.16.1 → 0.18.0

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

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

package/lib/agent/src/orchestrate/analyze/orchestrateAnalyzeWrite.d.ts

@@ -0,0 +1,8 @@
+import { AutoBeAnalyzeScenarioEvent, AutoBeAnalyzeWriteEvent } from "@autobe/interface";
+import { AutoBeAnalyzeFile } from "@autobe/interface/src/histories/contents/AutoBeAnalyzeFile";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../context/AutoBeContext";
+export declare const orchestrateAnalyzeWrite: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, scenario: AutoBeAnalyzeScenarioEvent, file: AutoBeAnalyzeFile.Scenario, progress: {
+    total: number;
+    completed: number;
+}) => Promise<AutoBeAnalyzeWriteEvent>;

package/lib/agent/src/orchestrate/analyze/orchestrateAnalyzeWrite.js

@@ -0,0 +1,242 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.orchestrateAnalyzeWrite = void 0;
+const __typia_transform__validateReport = __importStar(require("typia/lib/internal/_validateReport.js"));
+const typia_1 = __importDefault(require("typia"));
+const assertSchemaModel_1 = require("../../context/assertSchemaModel");
+const transformAnalyzeWriteHistories_1 = require("./histories/transformAnalyzeWriteHistories");
+const orchestrateAnalyzeWrite = (ctx, scenario, file, progress) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const pointer = {
+        value: null,
+    };
+    const { tokenUsage } = yield ctx.conversate({
+        source: "analyzeWrite",
+        controller: createController({
+            model: ctx.model,
+            pointer,
+        }),
+        histories: (0, transformAnalyzeWriteHistories_1.transformAnalyzeWriteHistories)(scenario, file),
+        enforceFunctionCall: true,
+        message: "Write requirement analysis report.",
+    });
+    if (pointer.value === null)
+        throw new Error("The Analyze Agent failed to create the document.");
+    const event = {
+        type: "analyzeWrite",
+        file: Object.assign(Object.assign({}, file), { content: pointer.value.content }),
+        tokenUsage: tokenUsage,
+        step: ((_b = (_a = ctx.state().analyze) === null || _a === void 0 ? void 0 : _a.step) !== null && _b !== void 0 ? _b : -1) + 1,
+        total: progress.total,
+        completed: ++progress.completed,
+        created_at: new Date().toISOString(),
+    };
+    ctx.dispatch(event);
+    return event;
+});
+exports.orchestrateAnalyzeWrite = orchestrateAnalyzeWrite;
+function createController(props) {
+    (0, assertSchemaModel_1.assertSchemaModel)(props.model);
+    const application = collection[props.model];
+    return {
+        protocol: "class",
+        name: "Planning",
+        application,
+        execute: {
+            write: (input) => __awaiter(this, void 0, void 0, function* () {
+                props.pointer.value = input;
+            }),
+        },
+    };
+}
+const claude = {
+    model: "claude",
+    options: {
+        reference: true,
+        separate: null
+    },
+    functions: [
+        {
+            name: "write",
+            parameters: {
+                description: " - The properties containing the document plan and initial\ncontent\n\n------------------------------\n\nCurrent Type: {@link IAutoBeAnalyzeWriteApplication.IProps}",
+                type: "object",
+                properties: {
+                    plan: {
+                        description: "The 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",
+                        type: "string"
+                    },
+                    content: {
+                        description: "The initial content or context for the document being written.\n\nThis may include:\n\n- User requirements and business goals\n- Existing documentation to build upon\n- Specific scenarios or use cases to document\n- Technical constraints or preferences\n- Related documents for reference\n\nThe content provides the raw material that the AI agent will transform\ninto structured, developer-ready documentation following the planning\nguidelines.\n\nThe AI agent will expand this content into comprehensive documentation\nthat:\n\n- Removes all ambiguity for backend developers\n- Provides specific, measurable requirements in natural language\n- Focuses on business logic and requirements, NOT technical implementation\n- STRICTLY PROHIBITED: Do NOT write database schemas, ERD, or API\n  specifications\n- Uses EARS format for all applicable requirements\n- Follows proper document linking conventions\n- Includes Mermaid diagrams with proper syntax (double quotes mandatory)",
+                        type: "string"
+                    }
+                },
+                required: [
+                    "plan",
+                    "content"
+                ],
+                additionalProperties: false,
+                $defs: {}
+            },
+            description: "Creates or updates planning documentation based on the provided plan and\ncontent structure.\n\nThis function is called by the AI agent to write detailed planning\ndocuments that will be used by backend developers to understand what needs\nto be built, why it's being built, and how it should function.",
+            validate: (() => { const _io0 = input => "string" === typeof input.plan && "string" === typeof input.content; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.plan || _report(_exceptionable, {
+                    path: _path + ".plan",
+                    expected: "string",
+                    value: input.plan
+                }), "string" === typeof input.content || _report(_exceptionable, {
+                    path: _path + ".content",
+                    expected: "string",
+                    value: input.content
+                })].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: "IAutoBeAnalyzeWriteApplication.IProps",
+                        value: input
+                    })) && _vo0(input, _path + "", true) || _report(true, {
+                        path: _path + "",
+                        expected: "IAutoBeAnalyzeWriteApplication.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
+                };
+            }; })()
+        }
+    ]
+};
+const collection = {
+    chatgpt: {
+        model: "chatgpt",
+        options: {
+            reference: true,
+            strict: false,
+            separate: null
+        },
+        functions: [
+            {
+                name: "write",
+                parameters: {
+                    description: " - The properties containing the document plan and initial\ncontent\n\n------------------------------\n\nCurrent Type: {@link IAutoBeAnalyzeWriteApplication.IProps}",
+                    type: "object",
+                    properties: {
+                        plan: {
+                            description: "The 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",
+                            type: "string"
+                        },
+                        content: {
+                            description: "The initial content or context for the document being written.\n\nThis may include:\n\n- User requirements and business goals\n- Existing documentation to build upon\n- Specific scenarios or use cases to document\n- Technical constraints or preferences\n- Related documents for reference\n\nThe content provides the raw material that the AI agent will transform\ninto structured, developer-ready documentation following the planning\nguidelines.\n\nThe AI agent will expand this content into comprehensive documentation\nthat:\n\n- Removes all ambiguity for backend developers\n- Provides specific, measurable requirements in natural language\n- Focuses on business logic and requirements, NOT technical implementation\n- STRICTLY PROHIBITED: Do NOT write database schemas, ERD, or API\n  specifications\n- Uses EARS format for all applicable requirements\n- Follows proper document linking conventions\n- Includes Mermaid diagrams with proper syntax (double quotes mandatory)",
+                            type: "string"
+                        }
+                    },
+                    required: [
+                        "plan",
+                        "content"
+                    ],
+                    additionalProperties: false,
+                    $defs: {}
+                },
+                description: "Creates or updates planning documentation based on the provided plan and\ncontent structure.\n\nThis function is called by the AI agent to write detailed planning\ndocuments that will be used by backend developers to understand what needs\nto be built, why it's being built, and how it should function.",
+                validate: (() => { const _io0 = input => "string" === typeof input.plan && "string" === typeof input.content; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.plan || _report(_exceptionable, {
+                        path: _path + ".plan",
+                        expected: "string",
+                        value: input.plan
+                    }), "string" === typeof input.content || _report(_exceptionable, {
+                        path: _path + ".content",
+                        expected: "string",
+                        value: input.content
+                    })].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: "IAutoBeAnalyzeWriteApplication.IProps",
+                            value: input
+                        })) && _vo0(input, _path + "", true) || _report(true, {
+                            path: _path + "",
+                            expected: "IAutoBeAnalyzeWriteApplication.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
+                    };
+                }; })()
+            }
+        ]
+    },
+    claude,
+    llama: claude,
+    deepseek: claude,
+    "3.1": claude,
+};
+//# sourceMappingURL=orchestrateAnalyzeWrite.js.map

package/lib/agent/src/orchestrate/analyze/orchestrateAnalyzeWrite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrateAnalyzeWrite.js","sourceRoot":"","sources":["../../../../../src/orchestrate/analyze/orchestrateAnalyzeWrite.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQA,kDAA0B;AAG1B,uEAAoE;AACpE,+FAA4F;AAGrF,MAAM,uBAAuB,GAAG,CACrC,GAAyB,EACzB,QAAoC,EACpC,IAAgC,EAChC,QAGC,EACiC,EAAE;;IACpC,MAAM,OAAO,GAA2D;QACtE,KAAK,EAAE,IAAI;KACZ,CAAC;IACF,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,GAAG,CAAC,UAAU,CAAC;QAC1C,MAAM,EAAE,cAAc;QACtB,UAAU,EAAE,gBAAgB,CAAQ;YAClC,KAAK,EAAE,GAAG,CAAC,KAAK;YAChB,OAAO;SACR,CAAC;QACF,SAAS,EAAE,IAAA,+DAA8B,EAAC,QAAQ,EAAE,IAAI,CAAC;QACzD,mBAAmB,EAAE,IAAI;QACzB,OAAO,EAAE,oCAAoC;KAC9C,CAAC,CAAC;IACH,IAAI,OAAO,CAAC,KAAK,KAAK,IAAI;QACxB,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;IAEtE,MAAM,KAAK,GAA4B;QACrC,IAAI,EAAE,cAAc;QACpB,IAAI,kCACC,IAAI,KACP,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,OAAO,GAC/B;QACD,UAAU,EAAE,UAAU;QACtB,IAAI,EAAE,CAAC,MAAA,MAAA,GAAG,CAAC,KAAK,EAAE,CAAC,OAAO,0CAAE,IAAI,mCAAI,CAAC,CAAC,CAAC,GAAG,CAAC;QAC3C,KAAK,EAAE,QAAQ,CAAC,KAAK;QACrB,SAAS,EAAE,EAAE,QAAQ,CAAC,SAAS;QAC/B,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;KACrC,CAAC;IACF,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IACpB,OAAO,KAAK,CAAC;AACf,CAAC,CAAA,CAAC;AAvCW,QAAA,uBAAuB,2BAuClC;AAEF,SAAS,gBAAgB,CAAiC,KAGzD;IACC,IAAA,qCAAiB,EAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC/B,MAAM,WAAW,GAA2B,UAAU,CACpD,KAAK,CAAC,KAAK,CACwD,CAAC;IACtE,OAAO;QACL,QAAQ,EAAE,OAAO;QACjB,IAAI,EAAE,UAAU;QAChB,WAAW;QACX,OAAO,EAAE;YACP,KAAK,EAAE,CAAO,KAAK,EAAE,EAAE;gBACrB,KAAK,CAAC,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC;YAC9B,CAAC,CAAA;SACuC;KAC3C,CAAC;AACJ,CAAC;AAED,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGT,CAAC;AACJ,MAAM,UAAU,GAAG;IACjB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAAoE;IAC3E,MAAM;IACN,KAAK,EAAE,MAAM;IACb,QAAQ,EAAE,MAAM;IAChB,KAAK,EAAE,MAAM;CACd,CAAC"}

package/lib/agent/src/orchestrate/analyze/structures/IAutoBeAnalyzeReviewApplication.d.ts

@@ -0,0 +1,105 @@
+export interface IAutoBeAnalyzeReviewApplication {
+    /**
+     * Enhances planning documentation to meet all quality standards and requirements.
+     *
+     * This function receives a document and outputs an improved version directly.
+     * The output IS the enhanced document itself, NOT review comments or feedback.
+     *
+     * The enhancement process includes:
+     * - Expanding sections that are too brief
+     * - Converting vague statements to specific EARS format requirements
+     * - Fixing Mermaid diagram syntax errors
+     * - Adding missing business processes and workflows
+     * - Ensuring proper document structure and completeness
+     *
+     * CRITICAL: The function outputs the actual document content that will be saved,
+     * not a review or analysis of the document. Any text output becomes part of
+     * the final document.
+     *
+     * @param props - The properties containing the document to enhance along with
+     *   plan and review criteria for guidance
+     */
+    review(props: IAutoBeAnalyzeReviewApplication.IProps): void;
+}
+export declare namespace IAutoBeAnalyzeReviewApplication {
+    interface IProps {
+        /**
+         * The enhancement criteria and guidelines that the agent must follow.
+         *
+         * This includes:
+         *
+         * - Minimum document length requirements
+         * - Section completeness checks
+         * - Link validation rules
+         * - Mermaid syntax validation (especially parentheses in labels)
+         * - Content specificity requirements
+         * - EARS format compliance
+         *
+         * The review criteria ensure that documentation is implementation-ready and
+         * removes all ambiguity for backend developers.
+         *
+         * Critical review points:
+         *
+         * - Mermaid diagrams MUST use double quotes for ALL labels
+         * - No spaces allowed between brackets and quotes in Mermaid
+         * - Requirements must be specific and measurable in natural language
+         * - Focus on business requirements and user scenarios
+         * - STRICTLY PROHIBITED: Reject if document contains database schemas or API
+         *   specifications
+         * - Business model and authentication requirements must be described in
+         *   natural language
+         */
+        review: string;
+        /**
+         * The document plan that was used to create the content.
+         *
+         * This helps the reviewer understand:
+         *
+         * - What sections should be present
+         * - The intended structure and organization
+         * - The target audience and purpose
+         * - Expected level of detail
+         *
+         * The enhancer uses this to ensure the improved content aligns with the
+         * original plan and covers all required topics comprehensively.
+         */
+        plan: string;
+        /**
+         * The actual markdown document content that incorporates review feedback.
+         *
+         * ⚠️ CRITICAL: This field contains a COMPLETE MARKDOWN DOCUMENT that has
+         * already incorporated the review criteria and plan requirements. This is
+         * NOT raw input to be reviewed - it is the FINAL, PRODUCTION-READY DOCUMENT
+         * that reflects all review feedback and is immediately usable.
+         *
+         * This content represents:
+         * - A fully-formed markdown document (.md file)
+         * - The result of applying review criteria to the original plan
+         * - A production-ready document for immediate deployment
+         * - Complete business requirements ready for developers
+         *
+         * The enhancer should treat this as the actual document content:
+         *
+         * - Length and completeness (minimum 2,000 characters, more for technical
+         *   docs)
+         * - All sections from the plan are fully written
+         * - No vague or abstract statements
+         * - Proper use of EARS format for requirements
+         * - Correct Mermaid diagram syntax (double quotes mandatory)
+         * - Appropriate level of detail for backend implementation
+         * - Proper document linking (descriptive text, not raw filenames)
+         *
+         * IMPORTANT: The enhancer's output IS this document, not comments about it:
+         *
+         * - If content is provided, it represents the actual document
+         * - The enhancer outputs the enhanced version AS the document itself
+         * - No meta-commentary or review feedback should be in the output
+         * - The output becomes the saved .md file directly
+         *
+         * Example of what this field contains:
+         * "# Service Overview\n## Vision\nThe service provides..." (actual document)
+         * NOT: "This document should cover service overview..." (review comment)
+         */
+        content: string;
+    }
+}

package/lib/agent/src/orchestrate/analyze/structures/IAutoBeAnalyzeReviewApplication.js

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

package/lib/agent/src/orchestrate/analyze/structures/IAutoBeAnalyzeReviewApplication.js.map

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

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

@@ -0,0 +1,78 @@
+import { AutoBeAnalyzeRole, CamelPattern } from "@autobe/interface";
+import { AutoBeAnalyzeFile } from "@autobe/interface/src/histories/contents/AutoBeAnalyzeFile";
+export interface IAutoBeAnalyzeScenarioApplication {
+    /**
+     * Compose project structure with roles 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
+     * 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`.
+     *
+     * @param input Prefix, roles, and files
+     * @returns
+     */
+    compose(input: IAutoBeAnalyzeScenarioApplication.IProps): void;
+}
+export declare namespace IAutoBeAnalyzeScenarioApplication {
+    interface IProps {
+        /** Reason for the analysis and composition of the project structure. */
+        reason: string;
+        /**
+         * Prefix for file names and variable names. This will be used for
+         * organizing documentation files.
+         *
+         * MUST use camelCase naming convention.
+         */
+        prefix: string & CamelPattern;
+        /** Roles to be assigned for the project */
+        roles: AutoBeAnalyzeRole[];
+        /**
+         * Language for document content. When specified by the user, this takes
+         * precedence over the locale setting for determining document language.
+         */
+        language?: string;
+        /**
+         * If the user has requested a specific number of pages, enter that number.
+         * Otherwise, provide an appropriate number of documents needed to meet the
+         * user's requirements. This number must always match the length of the
+         * files property, must be greater than 1, and must include the table of
+         * contents. For example, if the user requests 3 pages, the total should be
+         * 4, including the table of contents.
+         */
+        page: number;
+        /**
+         * # Document files to be generated
+         *
+         * File name must be English and it must contain the numbering and prefix.
+         *
+         * These files represent business documentation that may include:
+         *
+         * - Business requirements and functional specifications in natural language
+         * - 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)
+         * - Business logic and validation rules
+         * - STRICTLY PROHIBITED: Do NOT include database schemas, ERD, or API
+         *   specifications
+         * - All requirements must be written in natural language for clarity
+         *
+         * Generate files based on actual requirements gathered from conversation.
+         * Do not create unnecessary documentation - only generate what is needed to
+         * properly define the business requirements and system specifications.
+         *
+         * # Page Length Rules
+         *
+         * The number of documents must match the user's request, excluding the
+         * table of contents. For example, if the user requests 3 pages, a total of
+         * 4 documents should be generated, including the table of contents. If the
+         * user does not specify a number, generate a sufficient number of documents
+         * to adequately support the service.
+         */
+        files: Array<AutoBeAnalyzeFile.Scenario>;
+    }
+}

package/lib/agent/src/orchestrate/analyze/structures/IAutoBeAnalyzeScenarioApplication.js

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

package/lib/agent/src/orchestrate/analyze/structures/IAutoBeAnalyzeScenarioApplication.js.map

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

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

@@ -0,0 +1,70 @@
+export interface IAutoBeAnalyzeWriteApplication {
+    /**
+     * Creates or updates planning documentation based on the provided plan and
+     * content structure.
+     *
+     * This function is called by the AI agent to write detailed planning
+     * documents that will be used by backend developers to understand what needs
+     * to be built, why it's being built, and how it should function.
+     *
+     * @param props - The properties containing the document plan and initial
+     *   content
+     */
+    write(props: IAutoBeAnalyzeWriteApplication.IProps): void;
+}
+export declare namespace IAutoBeAnalyzeWriteApplication {
+    interface IProps {
+        /**
+         * The document planning structure that outlines what needs to be written.
+         *
+         * This includes:
+         *
+         * - Document title and purpose
+         * - Table of contents structure
+         * - Key sections to be covered
+         * - Relationships with other documents
+         * - Target audience (backend developers)
+         *
+         * The plan serves as a roadmap for the AI agent to ensure all necessary
+         * topics are covered in the documentation process.
+         *
+         * Example plan structure:
+         *
+         * - Service overview with business model
+         * - User roles and authentication requirements
+         * - Functional requirements with EARS format
+         * - Non-functional requirements
+         * - Business requirements in natural language
+         * - User scenarios and use cases
+         */
+        plan: string;
+        /**
+         * The initial content or context for the document being written.
+         *
+         * This may include:
+         *
+         * - User requirements and business goals
+         * - Existing documentation to build upon
+         * - Specific scenarios or use cases to document
+         * - Technical constraints or preferences
+         * - Related documents for reference
+         *
+         * The content provides the raw material that the AI agent will transform
+         * into structured, developer-ready documentation following the planning
+         * guidelines.
+         *
+         * The AI agent will expand this content into comprehensive documentation
+         * that:
+         *
+         * - Removes all ambiguity for backend developers
+         * - Provides specific, measurable requirements in natural language
+         * - Focuses on business logic and requirements, NOT technical implementation
+         * - STRICTLY PROHIBITED: Do NOT write database schemas, ERD, or API
+         *   specifications
+         * - Uses EARS format for all applicable requirements
+         * - Follows proper document linking conventions
+         * - Includes Mermaid diagrams with proper syntax (double quotes mandatory)
+         */
+        content: string;
+    }
+}

package/lib/agent/src/orchestrate/analyze/structures/IAutoBeAnalyzeWriteApplication.js

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

package/lib/agent/src/orchestrate/analyze/structures/IAutoBeAnalyzeWriteApplication.js.map

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

package/lib/agent/src/orchestrate/facade/transformFacadeStateMessage.d.ts

@@ -0,0 +1,2 @@
+import { AutoBeState } from "../../context/AutoBeState";
+export declare function transformFacadeStateMessage(state: AutoBeState): string;

package/lib/agent/src/orchestrate/facade/transformFacadeStateMessage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformFacadeStateMessage.js","sourceRoot":"","sources":["../../../../../src/orchestrate/facade/transformFacadeStateMessage.ts"],"names":[],"mappings":";;AAKA,kEA0BC;AA/BD,yCAA2C;AAK3C,SAAgB,2BAA2B,CAAC,KAAkB;IAC5D,MAAM,YAAY,GAAkB,eAAe,CAAC,KAAK,CAAC,CAAC;IAC3D,OAAO,0qJAAkC,OAAO,CAC9C,aAAa,EACb,kBAAU,CAAC,IAAI,CAAA;;;;;;;;;;;;;;;mBAeA,YAAY,CAAC,OAAO;kBACrB,YAAY,CAAC,MAAM;qBAChB,YAAY,CAAC,SAAS;gBAC3B,YAAY,CAAC,IAAI;mBACd,YAAY,CAAC,OAAO;KAClC,CACF,CAAC;AACJ,CAAC;AAED,SAAS,eAAe,CAAC,KAAkB;IACzC,MAAM,KAAK,GAAG,CACZ,GAEQ,EACR,EAAE;QACF,IAAI,KAAK,CAAC,OAAO,KAAK,IAAI,IAAI,GAAG,KAAK,IAAI;YAAE,OAAO,MAAM,CAAC;aACrD,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI;YAAE,OAAO,YAAY,CAAC;;YACzD,OAAO,aAAa,CAAC;IAC5B,CAAC,CAAC;IACF,OAAO;QACL,OAAO,EAAE,KAAK,CAAC,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,YAAY;QACvD,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC;QAC3B,SAAS,EAAE,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC;QACjC,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC;QACvB,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC;KAC9B,CAAC;AACJ,CAAC"}

package/lib/agent/src/orchestrate/index.d.ts

@@ -0,0 +1,5 @@
+export { orchestrateAnalyze as analyze } from "./analyze/orchestrateAnalyze";
+export { orchestrateInterface as interface } from "./interface/orchestrateInterface";
+export { orchestratePrisma as prisma } from "./prisma/orchestratePrisma";
+export { orchestrateRealize as realize } from "./realize/orchestrateRealize";
+export { orchestrateTest as test } from "./test/orchestrateTest";

package/lib/agent/src/orchestrate/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/orchestrate/index.ts"],"names":[],"mappings":";;;AAAA,mEAA6E;AAApE,6GAAA,kBAAkB,OAAW;AACtC,yEAAqF;AAA5E,iHAAA,oBAAoB,OAAa;AAC1C,gEAAyE;AAAhE,2GAAA,iBAAiB,OAAU;AACpC,mEAA6E;AAApE,6GAAA,kBAAkB,OAAW;AACtC,0DAAiE;AAAxD,uGAAA,eAAe,OAAQ"}

package/lib/agent/src/orchestrate/interface/histories/transformInterfaceAssetHistories.d.ts

@@ -0,0 +1,3 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeState } from "../../../context/AutoBeState";
+export declare const transformInterfaceAssetHistories: (state: AutoBeState) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/agent/src/orchestrate/interface/histories/transformInterfaceAssetHistories.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformInterfaceAssetHistories.js","sourceRoot":"","sources":["../../../../../../src/orchestrate/interface/histories/transformInterfaceAssetHistories.ts"],"names":[],"mappings":";;;AAMA,+BAA0B;AAInB,MAAM,gCAAgC,GAAG,CAC9C,KAAkB,EAGlB,EAAE;IACF,MAAM,OAAO,GAAyB,KAAK,CAAC,OAAQ,CAAC;IACrD,MAAM,MAAM,GAAwB,KAAK,CAAC,MAAO,CAAC;IAClD,OAAO;QACL;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,kBAAkB;YACxB,IAAI,EAAE;gBACJ,iEAAiE;gBACjE,EAAE;gBACF,kEAAkE;gBAClE,8DAA8D;gBAC9D,EAAE;gBACF,eAAe;gBACf,iBAAiB;gBACjB,EAAE;gBACF,OAAO,CAAC,MAAM;gBACd,EAAE;gBACF,8BAA8B;gBAC9B,gCAAgC;gBAChC,EAAE;gBACF,SAAS;gBACT,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC;gBAC7B,KAAK;aACN,CAAC,IAAI,CAAC,IAAI,CAAC;SACb;QACD;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,kBAAkB;YACxB,IAAI,EAAE;gBACJ,6DAA6D;gBAC7D,gGAAgG;gBAChG,wDAAwD;gBACxD,EAAE;gBACF,8CAA8C;gBAC9C,EAAE;gBACF,iEAAiE;gBACjE,yEAAyE;gBACzE,iGAAiG;gBACjG,2BAA2B;gBAC3B,2FAA2F;gBAC3F,wEAAwE;gBACxE,4FAA4F;gBAC5F,EAAE;gBACF,qBAAqB;gBACrB,SAAS;gBACT,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC;gBAC9B,KAAK;gBACL,EAAE;gBACF,iCAAiC;gBACjC,SAAS;gBACT,IAAI,CAAC,SAAS,CACX,MAAM,CAAC,QAAgD,CAAC,QAAQ,CAClE;gBACD,KAAK;aACN,CAAC,IAAI,CAAC,IAAI,CAAC;SACb;KACF,CAAC;AACJ,CAAC,CAAC;AAhEW,QAAA,gCAAgC,oCAgE3C"}

package/lib/agent/src/orchestrate/interface/histories/transformInterfaceAuthorizationsHistories.d.ts

@@ -0,0 +1,4 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeAnalyzeRole } from "@autobe/interface";
+import { AutoBeState } from "../../../context/AutoBeState";
+export declare const transformInterfaceAuthorizationsHistories: (state: AutoBeState, role: AutoBeAnalyzeRole) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/agent/src/orchestrate/interface/histories/transformInterfaceAuthorizationsHistories.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformInterfaceAuthorizationsHistories = void 0;
+const uuid_1 = require("uuid");
+const transformInterfaceAssetHistories_1 = require("./transformInterfaceAssetHistories");
+const transformInterfaceAuthorizationsHistories = (state, role) => {
+    return [
+        {
+            type: "systemMessage",
+            id: (0, uuid_1.v4)(),
+            created_at: new Date().toISOString(),
+            text: "# Authorization API Operation Generator System Prompt\n\n## 1. Overview\n\nYou are the Authorization API Operation Generator, specializing in creating JWT-based **authentication and authorization ONLY** API operations for specific user roles. Your mission is to generate essential authentication operations plus additional operations that are clearly supported by the Prisma schema structure.\n\n## 2. Your Mission\n\nGenerate JWT authentication operations in two categories:\n1. **Essential Operations**: Core authentication flows that every role needs\n2. **Schema-Driven Operations**: Additional operations based on what the Prisma schema actually supports\n\n## 2.1. Authentication Scope Definition\n\n**INCLUDE (Authentication/Authorization Operations):**\n- Core authentication flows (register, login, logout)\n- JWT token management\n- Schema-supported additional operations\n\n**EXCLUDE (User Management Operations):**\n- General profile retrieval and viewing\n- Profile information updates (except password changes)\n- User preference management\n- Non-security related account settings\n\n## 3. Essential Operations (Generate If Basic Fields Exist)\n\nThese operations should be generated for every role if the basic authentication fields exist in the schema:\n\n### 3.1. Core Authentication Flow\n\n#### Registration\n- **Condition**: Role table has identity field + authentication field\n- **Path**: `/auth/{roleName}/register`\n- **Method**: `POST`\n- **Function Name**: `\"signUp\"`\n- **Purpose**: Create new user account and issue initial JWT tokens\n- **Auth Required**: None (public)\n- **Response Body Requirement**: Must include `setHeaders` field with `{ Authorization: string }` structure\n\n#### Login\n- **Condition**: Role table has authentication fields\n- **Path**: `/auth/{roleName}/login`\n- **Method**: `POST`\n- **Function Name**: `\"signIn\"`\n- **Purpose**: Authenticate user and issue JWT tokens\n- **Auth Required**: None (public)\n\n#### Logout\n- **Path**: `/auth/{roleName}/logout`\n- **Method**: `POST`\n- **Function Name**: `\"signOut\"`\n- **Purpose**: Invalidate current JWT session\n- **Auth Required**: Authenticated user\n\n#### Token Validation\n- **Path**: `/auth/{roleName}/validate`\n- **Method**: `POST`\n- **Function Name**: `\"validateToken\"`\n- **Purpose**: Validate JWT token and return authentication status\n- **Auth Required**: None (validates provided token)\n\n#### Change Password\n- **Condition**: Schema has password field\n- **Path**: `/auth/{roleName}/password`\n- **Method**: `PUT`\n- **Function Name**: `\"changePassword\"`\n- **Purpose**: Change user password with current password verification\n- **Auth Required**: Authenticated user\n\n## 4. Schema-Driven Operations (Generate Based on Available Fields)\n\n**Analyze the Prisma schema for the role's table and generate additional operations ONLY for features that are clearly supported by the schema fields:**\n\n### 4.1. Token Refresh Operations\n- **Generate IF**: Schema has refresh token storage fields (e.g., `refreshToken`, `refresh_token`, `refreshTokenHash`)\n- **Path**: `/auth/{roleName}/refresh`\n- **Method**: `POST`\n- **Function Name**: `\"refreshToken\"`\n- **Response Body Requirement**: Must include `setHeaders` field with `{ Authorization: string }` structure\n\n### 4.2. Email Verification Operations\n- **Generate IF**: Schema has email verification fields (e.g., `emailVerified`, `email_verified`, `verificationToken`, `verification_token`)\n- **Paths & Functions**: \n  - `/auth/{roleName}/verify/email` \u2192 `\"requestEmailVerification\"`\n  - `/auth/{roleName}/verify/email/confirm` \u2192 `\"confirmEmailVerification\"`\n\n### 4.3. Password Reset Operations\n- **Generate IF**: Schema has password reset fields (e.g., `resetToken`, `reset_token`, `passwordResetToken`, `password_reset_token`)\n- **Paths & Functions**:\n  - `/auth/{roleName}/password/reset` \u2192 `\"requestPasswordReset\"`\n  - `/auth/{roleName}/password/reset/confirm` \u2192 `\"confirmPasswordReset\"`\n\n### 4.4. Advanced Token Management\n- **Generate IF**: Schema has advanced token tracking fields\n- **Possible Operations**:\n  - `/auth/{roleName}/tokens/revoke-all` \u2192 `\"revokeAllTokens\"`\n  - `/auth/{roleName}/sessions` \u2192 `\"listActiveSessions\"`\n  - `/auth/{roleName}/sessions/{sessionId}` \u2192 `\"revokeSession\"`\n\n## 5. Naming Convention Rules\n\n### 5.1. Endpoint Path Conventions\n- Use RESTful resource-based paths\n- Use kebab-case for multi-word segments\n- Keep paths descriptive of the resource and action\n- Example: `/auth/user/password/reset/confirm`\n\n### 5.2. Function Name Conventions  \n- Use camelCase for function names\n- Start with action verbs that clearly describe the operation\n- Make function names self-explanatory and business-oriented\n- Examples:\n  - `signUp` (not `register`)\n  - `signIn` (not `login`) \n  - `refreshToken` (not `issue`)\n  - `requestPasswordReset` (not `resetPassword`)\n  - `confirmEmailVerification` (not `verifyEmail`)\n\n### 5.3. Path vs Function Name Relationship\n- **Path**: Describes the HTTP resource and REST endpoint\n- **Function Name**: Describes the business operation/action\n- They should be related but NOT identical\n- Function names should be more action-oriented\n- Paths should be more resource-oriented\n\n### 5.4. Examples of Good Naming\n\n| Endpoint Path | Function Name | Purpose |\n|---------------|---------------|---------|\n| `/auth/user/register` | `signUp` | User registration |\n| `/auth/user/login` | `signIn` | User authentication |  \n| `/auth/user/refresh` | `refreshToken` | Token refresh |\n| `/auth/user/verify/email` | `requestEmailVerification` | Request email verification |\n| `/auth/user/verify/email/confirm` | `confirmEmailVerification` | Confirm email verification |\n| `/auth/user/password/reset` | `requestPasswordReset` | Request password reset |\n| `/auth/user/password/reset/confirm` | `confirmPasswordReset` | Confirm password reset |\n| `/auth/user/tokens/revoke-all` | `revokeAllTokens` | Revoke all user tokens |\n\n## 6. Schema Analysis Process\n\n### 6.1. Step-by-Step Analysis\n\n1. **Identify Role Table**: Find the table corresponding to the role name\n2. **Check Essential Fields**: Verify basic authentication fields exist\n3. **Scan for Additional Features**: Look for fields that indicate additional authentication capabilities:\n   - Email fields + verification status/token fields \u2192 Email verification operations\n   - Reset token fields \u2192 Password reset operations  \n   - Refresh token fields \u2192 Token refresh operations\n   - Session/token tracking fields \u2192 Advanced token management\n4. **Generate Operations**: Create operations for confirmed capabilities only\n\n### 6.2. Field Pattern Recognition\n\nLook for these common field patterns in the role's schema:\n\n**Email Verification Indicators:**\n- `emailVerified` + `verificationToken`\n- `email_verified` + `verification_token`\n- `isEmailVerified` + related token fields\n\n**Password Reset Indicators:**\n- `resetToken` + `resetTokenExpiry`\n- `password_reset_token` + expiry fields\n- `passwordResetToken` + related fields\n\n**Token Management Indicators:**\n- `refreshToken` or `refresh_token`\n- `tokenVersion` or `jwt_version`\n- Session tracking fields\n\n## 7. Implementation Rules\n\n### 7.1. Conservative Approach\n- **If field exists in schema**: Generate corresponding operation\n- **If field missing**: Skip the operation entirely\n- **If unsure about field purpose**: Skip rather than assume\n\n### 7.2. Operation Documentation\nEach operation must document:\n- Which specific schema fields it uses\n- Why the operation is possible (schema evidence)\n- Any limitations based on available fields\n- Clear distinction between endpoint path and function name\n\n## 8. Description Requirements\n\n### 8.1. Schema-Aware Descriptions\n\n**Paragraph 1**: Purpose and functionality referencing specific schema fields\n\n**Paragraph 2**: JWT implementation details using confirmed available fields\n\n**Paragraph 3**: Role-specific integration and business context\n\n**Paragraph 4**: Security considerations within schema constraints\n\n**Paragraph 5**: Related operations and authentication workflow integration\n\n### 8.2. SetHeaders Response Field Requirement\n\nFor operations with function names `signUp` (registration) and `refreshToken` (token refresh), the response body schema MUST include a `setHeaders` field with the following structure:\n\n```typescript\n/**\n * Header setting value.\n *\n * The client can assign this value to {@link IConnection.headers}.\n *\n * However, this process is automatically performed when calling the\n * relevant SDK function.\n */\nsetHeaders: { Authorization: string };\n```\n\nThis field enables automatic header assignment for subsequent authenticated API calls.\n\n## 9. Critical Requirements\n\n- **Essential Operations MANDATORY**: ALWAYS generate ALL 5 essential operations (signUp, signIn, signOut, validateToken, changePassword) for every role\n- **Schema-Driven Additions**: Add operations only for schema-supported features\n- **Field Verification**: Reference actual field names from the schema for additional features\n- **Never Skip Essentials**: Even if uncertain about schema fields, ALWAYS include the 5 core operations\n- **Proper Naming**: Ensure endpoint paths and function names follow conventions and are distinct\n- **SetHeaders Field Requirement**: `signUp` and `refreshToken` operations MUST include `setHeaders: { Authorization: string }` in response body\n- **Function Call Required**: Use `makeOperations()` with all generated operations\n\n## 10. Implementation Strategy\n\n1. **ALWAYS Generate Essential Operations FIRST**: Create ALL 5 core authentication operations (signUp, signIn, signOut, validateToken, changePassword) for every role - this is MANDATORY\n2. **Analyze Schema Fields**: Systematically scan for additional authentication capabilities\n3. **Generate Schema-Supported Operations**: Add operations for confirmed schema features\n4. **Apply Naming Conventions**: Ensure proper path and function naming\n5. **Document Rationale**: Explain which schema fields enable each operation\n6. **Function Call**: Submit complete authentication API\n\n**CRITICAL RULE**: Even if you're unsure about the schema or can only confirm basic authentication, you MUST still generate all 5 essential operations. Never generate only some of them.\n\nYour implementation should provide a complete authentication system with essential operations plus all additional operations that the Prisma schema clearly supports, ensuring every operation can be fully implemented with the available database structure, with clear and consistent naming conventions that distinguish between REST endpoints and business function names." /* AutoBeSystemPromptConstant.INTERFACE_AUTHORIZATION */,
+        },
+        ...(0, transformInterfaceAssetHistories_1.transformInterfaceAssetHistories)(state),
+        {
+            type: "assistantMessage",
+            id: (0, uuid_1.v4)(),
+            created_at: new Date().toISOString(),
+            text: [
+                "You have to make API operations for the given role:",
+                "",
+                "## Role",
+                "",
+                "```json",
+                JSON.stringify(role),
+                "```",
+                "",
+                "",
+            ].join("\n"),
+        },
+    ];
+};
+exports.transformInterfaceAuthorizationsHistories = transformInterfaceAuthorizationsHistories;
+//# sourceMappingURL=transformInterfaceAuthorizationsHistories.js.map