@autobe/agent 0.17.1 → 0.19.1

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,244 @@
+"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 { histories, tokenUsage } = yield ctx.conversate({
+        source: "analyzeWrite",
+        controller: createController({
+            model: ctx.model,
+            pointer,
+        }),
+        histories: (0, transformAnalyzeWriteHistories_1.transformAnalyzeWriteHistories)(ctx, scenario, file),
+        enforceFunctionCall: true,
+        message: "Write requirement analysis report.",
+    });
+    if (pointer.value === null) {
+        console.log(JSON.stringify(histories, null, 2));
+        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,SAAS,EAAE,UAAU,EAAE,GAAG,MAAM,GAAG,CAAC,UAAU,CAAC;QACrD,MAAM,EAAE,cAAc;QACtB,UAAU,EAAE,gBAAgB,CAAQ;YAClC,KAAK,EAAE,GAAG,CAAC,KAAK;YAChB,OAAO;SACR,CAAC;QACF,SAAS,EAAE,IAAA,+DAA8B,EAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,CAAC;QAC9D,mBAAmB,EAAE,IAAI;QACzB,OAAO,EAAE,oCAAoC;KAC9C,CAAC,CAAC;IACH,IAAI,OAAO,CAAC,KAAK,KAAK,IAAI,EAAE,CAAC;QAC3B,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;QAChD,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;IACtE,CAAC;IAED,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;AAzCW,QAAA,uBAAuB,2BAyClC;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
+     *
+     * DO: Output the actual document content that will be saved.
+     * DO NOT: Output review comments or analysis of the document.
+     *
+     * Note: 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:
+         *
+         * - DO: Use double quotes for ALL labels in Mermaid diagrams
+         * - DO NOT: Use spaces between brackets and quotes in Mermaid
+         * - DO: Make requirements specific and measurable in natural language
+         * - DO: Focus on business requirements and user scenarios
+         * - DO NOT: Accept documents containing database schemas or API specifications
+         * - DO: Describe business model and authentication requirements 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.
+         *
+         * This field contains a COMPLETE MARKDOWN DOCUMENT that has already
+         * incorporated the review criteria and plan requirements.
+         *
+         * DO: Treat this as the final, production-ready document.
+         * DO NOT: Treat this as raw input to be reviewed.
+         *
+         * 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)
+         *
+         * The enhancer outputs the document itself:
+         *
+         * - 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";
+import { tags } from "typia";
+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.
+         *
+         * DO: 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
+         * - DO NOT: Include database schemas, ERD, or API specifications
+         * - DO: Write all requirements 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> & tags.MinItems<1>;
+    }
+}

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/{orchestrate → agent/src/orchestrate}/interface/histories/transformInterfaceAssetHistories.js

@@ -49,6 +49,7 @@ const transformInterfaceAssetHistories = (state) => {
                 "4. Verify EVERY field reference against the actual schema before including in descriptions",
                 "",
                 "## Prisma DB Schema",
+                "",
                 "```json",
                 JSON.stringify(prisma.schemas),
                 "```",

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,EAAE;gBACF,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;AAjEW,QAAA,gCAAgC,oCAiE3C"}

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>;