@autobe/agent 0.17.1 → 0.18.0

package/lib/orchestrate/analyze/orchestrateAnalyzeWrite.js

@@ -1,347 +0,0 @@
-"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 core_1 = require("@agentica/core");
-const typia_1 = __importDefault(require("typia"));
-const assertSchemaModel_1 = require("../../context/assertSchemaModel");
-const enforceToolCall_1 = require("../../utils/enforceToolCall");
-const AutoBeAnalyzeFileSystem_1 = require("./AutoBeAnalyzeFileSystem");
-const transformAnalyzeWriteHistories_1 = require("./transformAnalyzeWriteHistories");
-const orchestrateAnalyzeWrite = (ctx, input) => {
-    const controller = createController({
-        model: ctx.model,
-        execute: new AutoBeAnalyzeFileSystem_1.AutoBeAnalyzeFileSystem({ [input.targetFile]: "" }),
-        setDocument: input.setDocument,
-    });
-    const agent = new core_1.MicroAgentica({
-        controllers: [controller],
-        model: ctx.model,
-        vendor: ctx.vendor,
-        config: Object.assign(Object.assign({}, ctx.config), { executor: {
-                describe: null,
-            } }),
-        histories: [...(0, transformAnalyzeWriteHistories_1.transformAnalyzeWriteHistories)(ctx, input)],
-    });
-    (0, enforceToolCall_1.enforceToolCall)(agent);
-    return agent;
-};
-exports.orchestrateAnalyzeWrite = orchestrateAnalyzeWrite;
-function createController(props) {
-    (0, assertSchemaModel_1.assertSchemaModel)(props.model);
-    const application = collection[props.model];
-    return {
-        protocol: "class",
-        name: "Planning",
-        application,
-        execute: {
-            createOrUpdateFiles: (input) => __awaiter(this, void 0, void 0, function* () {
-                const fileMap = yield props.execute.createOrUpdateFiles(input);
-                props.setDocument(fileMap);
-                return fileMap;
-            }),
-        },
-    };
-}
-const claude = {
-    model: "claude",
-    options: {
-        reference: true,
-        separate: null
-    },
-    functions: [
-        {
-            name: "createOrUpdateFiles",
-            parameters: {
-                type: "object",
-                properties: {
-                    files: {
-                        type: "array",
-                        items: {
-                            $ref: "#/$defs/IFile"
-                        },
-                        minItems: 1
-                    }
-                },
-                required: [
-                    "files"
-                ],
-                additionalProperties: false,
-                $defs: {
-                    IFile: {
-                        type: "object",
-                        properties: {
-                            reason: {
-                                description: "Describe briefly why you made this document, and if you have any plans for\nthe next one.",
-                                type: "string"
-                            },
-                            filename: {
-                                description: "Filename to generate or overwrite.",
-                                type: "string",
-                                pattern: "((.*)\\.md)$"
-                            },
-                            markdown: {
-                                description: "Markdown file content. Only write the content of the file. Do not include\nany questions. This should contain only the contents of the file. Do not\nwrite down any questions or appreciation. For example, remove a sentence\nsuch as \"Is it okay if we proceed with the table of contents? Please let me\nknow if there is anything to add or exclude from the table of contents!\"",
-                                type: "string"
-                            }
-                        },
-                        required: [
-                            "reason",
-                            "filename",
-                            "markdown"
-                        ]
-                    },
-                    Recordstringstring: {
-                        description: "Construct a type with a set of properties K of type T",
-                        type: "object",
-                        properties: {},
-                        required: [],
-                        additionalProperties: {
-                            type: "string"
-                        }
-                    }
-                }
-            },
-            output: {
-                $ref: "#/$defs/Recordstringstring"
-            },
-            validate: (() => { const _io0 = input => Array.isArray(input.files) && (1 <= input.files.length && input.files.every(elem => "object" === typeof elem && null !== elem && _io1(elem))); const _io1 = input => "string" === typeof input.reason && ("string" === typeof input.filename && RegExp(/(.*)\.md$/).test(input.filename)) && "string" === typeof input.markdown; const _vo0 = (input, _path, _exceptionable = true) => [(Array.isArray(input.files) || _report(_exceptionable, {
-                    path: _path + ".files",
-                    expected: "(Array<IFile> & MinItems<1>)",
-                    value: input.files
-                })) && ((1 <= input.files.length || _report(_exceptionable, {
-                    path: _path + ".files",
-                    expected: "Array<> & MinItems<1>",
-                    value: input.files
-                })) && input.files.map((elem, _index2) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
-                    path: _path + ".files[" + _index2 + "]",
-                    expected: "IFile",
-                    value: elem
-                })) && _vo1(elem, _path + ".files[" + _index2 + "]", true && _exceptionable) || _report(_exceptionable, {
-                    path: _path + ".files[" + _index2 + "]",
-                    expected: "IFile",
-                    value: elem
-                })).every(flag => flag)) || _report(_exceptionable, {
-                    path: _path + ".files",
-                    expected: "(Array<IFile> & MinItems<1>)",
-                    value: input.files
-                })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.reason || _report(_exceptionable, {
-                    path: _path + ".reason",
-                    expected: "string",
-                    value: input.reason
-                }), "string" === typeof input.filename && RegExp(/(.*)\.md$/).test(input.filename) || _report(_exceptionable, {
-                    path: _path + ".filename",
-                    expected: "`${string}.md`",
-                    value: input.filename
-                }), "string" === typeof input.markdown || _report(_exceptionable, {
-                    path: _path + ".markdown",
-                    expected: "string",
-                    value: input.markdown
-                })].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: "__type",
-                        value: input
-                    })) && _vo0(input, _path + "", true) || _report(true, {
-                        path: _path + "",
-                        expected: "__type",
-                        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: "createOrUpdateFiles",
-                parameters: {
-                    type: "object",
-                    properties: {
-                        files: {
-                            description: "@minItems 1",
-                            type: "array",
-                            items: {
-                                $ref: "#/$defs/IFile"
-                            }
-                        }
-                    },
-                    required: [
-                        "files"
-                    ],
-                    additionalProperties: false,
-                    $defs: {
-                        IFile: {
-                            type: "object",
-                            properties: {
-                                reason: {
-                                    description: "Describe briefly why you made this document, and if you have any plans for\nthe next one.",
-                                    type: "string"
-                                },
-                                filename: {
-                                    description: "Filename to generate or overwrite.\n\n\n@pattern ((.*)\\.md)$",
-                                    type: "string"
-                                },
-                                markdown: {
-                                    description: "Markdown file content. Only write the content of the file. Do not include\nany questions. This should contain only the contents of the file. Do not\nwrite down any questions or appreciation. For example, remove a sentence\nsuch as \"Is it okay if we proceed with the table of contents? Please let me\nknow if there is anything to add or exclude from the table of contents!\"",
-                                    type: "string"
-                                }
-                            },
-                            required: [
-                                "reason",
-                                "filename",
-                                "markdown"
-                            ]
-                        },
-                        Recordstringstring: {
-                            description: "Construct a type with a set of properties K of type T",
-                            type: "object",
-                            properties: {},
-                            required: [],
-                            additionalProperties: {
-                                type: "string"
-                            }
-                        }
-                    }
-                },
-                output: {
-                    $ref: "#/$defs/Recordstringstring"
-                },
-                validate: (() => { const _io0 = input => Array.isArray(input.files) && (1 <= input.files.length && input.files.every(elem => "object" === typeof elem && null !== elem && _io1(elem))); const _io1 = input => "string" === typeof input.reason && ("string" === typeof input.filename && RegExp(/(.*)\.md$/).test(input.filename)) && "string" === typeof input.markdown; const _vo0 = (input, _path, _exceptionable = true) => [(Array.isArray(input.files) || _report(_exceptionable, {
-                        path: _path + ".files",
-                        expected: "(Array<IFile> & MinItems<1>)",
-                        value: input.files
-                    })) && ((1 <= input.files.length || _report(_exceptionable, {
-                        path: _path + ".files",
-                        expected: "Array<> & MinItems<1>",
-                        value: input.files
-                    })) && input.files.map((elem, _index2) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
-                        path: _path + ".files[" + _index2 + "]",
-                        expected: "IFile",
-                        value: elem
-                    })) && _vo1(elem, _path + ".files[" + _index2 + "]", true && _exceptionable) || _report(_exceptionable, {
-                        path: _path + ".files[" + _index2 + "]",
-                        expected: "IFile",
-                        value: elem
-                    })).every(flag => flag)) || _report(_exceptionable, {
-                        path: _path + ".files",
-                        expected: "(Array<IFile> & MinItems<1>)",
-                        value: input.files
-                    })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.reason || _report(_exceptionable, {
-                        path: _path + ".reason",
-                        expected: "string",
-                        value: input.reason
-                    }), "string" === typeof input.filename && RegExp(/(.*)\.md$/).test(input.filename) || _report(_exceptionable, {
-                        path: _path + ".filename",
-                        expected: "`${string}.md`",
-                        value: input.filename
-                    }), "string" === typeof input.markdown || _report(_exceptionable, {
-                        path: _path + ".markdown",
-                        expected: "string",
-                        value: input.markdown
-                    })].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: "__type",
-                            value: input
-                        })) && _vo0(input, _path + "", true) || _report(true, {
-                            path: _path + "",
-                            expected: "__type",
-                            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/orchestrate/analyze/orchestrateAnalyzeWrite.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"orchestrateAnalyzeWrite.js","sourceRoot":"","sources":["../../../src/orchestrate/analyze/orchestrateAnalyzeWrite.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,yCAAoE;AAGpE,kDAA0B;AAG1B,uEAAoE;AACpE,iEAA8D;AAC9D,uEAImC;AAEnC,qFAAkF;AAE3E,MAAM,uBAAuB,GAAG,CACrC,GAAyB,EACzB,KAOC,EACqB,EAAE;IACxB,MAAM,UAAU,GAAG,gBAAgB,CAAQ;QACzC,KAAK,EAAE,GAAG,CAAC,KAAK;QAChB,OAAO,EAAE,IAAI,iDAAuB,CAAC,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE,EAAW,EAAE,CAAC;QACzE,WAAW,EAAE,KAAK,CAAC,WAAW;KAC/B,CAAC,CAAC;IAEH,MAAM,KAAK,GAAG,IAAI,oBAAa,CAAC;QAC9B,WAAW,EAAE,CAAC,UAAU,CAAC;QACzB,KAAK,EAAE,GAAG,CAAC,KAAK;QAChB,MAAM,EAAE,GAAG,CAAC,MAAM;QAClB,MAAM,kCACD,GAAG,CAAC,MAAM,KACb,QAAQ,EAAE;gBACR,QAAQ,EAAE,IAAI;aACf,GACF;QACD,SAAS,EAAE,CAAC,GAAG,IAAA,+DAA8B,EAAC,GAAG,EAAE,KAAK,CAAC,CAAC;KAC3D,CAAC,CAAC;IACH,IAAA,iCAAe,EAAC,KAAK,CAAC,CAAC;IACvB,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AA/BW,QAAA,uBAAuB,2BA+BlC;AAEF,SAAS,gBAAgB,CAAiC,KAIzD;IACC,IAAA,qCAAiB,EAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC/B,MAAM,WAAW,GAA2B,UAAU,CACpD,KAAK,CAAC,KAAK,CACyB,CAAC;IACvC,OAAO;QACL,QAAQ,EAAE,OAAO;QACjB,IAAI,EAAE,UAAU;QAChB,WAAW;QACX,OAAO,EAAE;YACP,mBAAmB,EAAE,CAAO,KAAK,EAAE,EAAE;gBACnC,MAAM,OAAO,GAAG,MAAM,KAAK,CAAC,OAAO,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;gBAC/D,KAAK,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;gBAC3B,OAAO,OAAO,CAAC;YACjB,CAAC,CAAA;SACiC;KACrC,CAAC;AACJ,CAAC;AAED,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIT,CAAC;AACJ,MAAM,UAAU,GAAG;IACjB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAIJ;IACH,MAAM;IACN,KAAK,EAAE,MAAM;IACb,QAAQ,EAAE,MAAM;IAChB,KAAK,EAAE,MAAM;CACd,CAAC"}

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

@@ -1,68 +0,0 @@
-import { AutoBeAnalyzeRole } from "@autobe/interface";
-import { IFile } from "../AutoBeAnalyzeFileSystem";
-export interface IComposeInput {
-    /** Reason for the analysis and composition of the project structure. */
-    reason: string;
-    /**
-     * Prefix for file names and all prisma schema files, table, interface, and
-     * variable names.
-     */
-    prefix: string;
-    /** Roles to be assigned for the project */
-    roles: AutoBeAnalyzeRole[];
-    /**
-     * 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
-     * - User journey mapping and use case scenarios
-     * - Business rules and workflow definitions
-     * - Service architecture and system design overview
-     * - Data flow and integration requirements
-     * - User roles and permission matrix
-     * - API endpoint specifications and contracts
-     * - Business logic and validation rules
-     *
-     * 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<Pick<IFile, "filename" | "reason">>;
-}
-export interface IAutoBeAnalyzeComposerApplication {
-    /**
-     * 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: IComposeInput): IComposeInput;
-}

package/lib/orchestrate/analyze/structures/IAutoBeAnalyzeComposerApplication.js

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

package/lib/orchestrate/analyze/structures/IAutoBeAnalyzeComposerApplication.js.map

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

package/lib/orchestrate/analyze/transformAnalyzeReviewerHistories.d.ts

@@ -1,5 +0,0 @@
-import { IAgenticaHistoryJson } from "@agentica/core";
-export declare const transformAnalyzeReviewerHistories: (input: {
-    /** Total file names */
-    files: Record<string, string>;
-}) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/orchestrate/analyze/transformAnalyzeReviewerHistories.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformAnalyzeReviewerHistories = void 0;
-const uuid_1 = require("uuid");
-const transformAnalyzeReviewerHistories = (input) => {
-    return [
-        {
-            id: (0, uuid_1.v4)(),
-            created_at: new Date().toISOString(),
-            type: "assistantMessage",
-            text: [
-                "Below are all of the files.",
-                "```json",
-                JSON.stringify(input.files),
-                "```",
-            ].join("\n"),
-        },
-        {
-            id: (0, uuid_1.v4)(),
-            created_at: new Date().toISOString(),
-            type: "systemMessage",
-            text: "# Reviewer Agent Operating Guidelines\n\n## Core Principles\n- **Review only the document currently being viewed.** Ignore any references to other documents, even if implied.\n- If the current document is **not a table of contents page** (i.e., does not start with `00`) and references external documents, **instruct the planner to clear all content and rewrite the current document** to focus solely on its assigned scope.\n- **Do not request the creation of any other pages or documents.** Each agent must write and review **only the single page assigned to them.**\n- Attempts to write or request other pages are strictly prohibited. If such attempts occur, **command the agent to focus exclusively on the current page.**\n- The table of contents page (starting with `00`) is exempt from content rewriting rules unless it contains invalid references.\n- Other documents will be handled by other agents, so **do not request their creation** under any circumstances.\n\n## Role of the Reviewer\n- The Reviewer Agent\u2019s role is to **ensure the document contains sufficient information** before it is delivered to developers.\n- **Review all hyperlinks** currently referenced in the markdown and ensure they are valid or appropriately handled:\n  - Internal anchor links (e.g., `#section-title`) must point to existing headings within the document.\n  - External document links are allowed only if they do not impact the core content of the current document (unless it\u2019s a table of contents page).\n- **Do not create files** that are not specified in the table of contents.\n- If the user specifies an **exact number of pages**, that number **must be strictly followed.**\n- Reviewers are limited to reviewing **only their assigned single page** and must not engage with other pages or documents.\n- If an agent requests creation of other pages, **command them to stop** and enforce focus on the current page.\n\n## Conditions Requiring `reject`\nThe Reviewer Agent **must** call `reject` with a reason, feedback, and suggestions in the following cases:\n- Document length is **less than 2,000 characters** (excluding table of contents pages).\n- Any section listed in the table of contents is **missing or incomplete**.\n- Internal anchor links (e.g., `#section-title`) point to **non-existent headings** within the document.\n- External document references in a non-table-of-contents page impact the **core content** of the document.\n- Content is **insufficient relative to the number of headings** (e.g., average content per heading is less than 300 characters).\n- Any violation of the **page-based work division** rules (e.g., attempts to write or reference content outside the assigned page).\n\n## Conditions for `accept`\nThe Reviewer Agent **must** call `accept` only when **all** of the following conditions are met:\n- Document length is **between 2,000 and 6,000 characters** (excluding table of contents pages).\n- All sections listed in the table of contents are **fully written** with sufficient detail.\n- All internal anchor links point to **existing headings** within the document.\n- External document references (if any) do not impact the **core content** of the document, or the document is a table of contents page.\n- Content is **sufficient relative to the number of headings** (e.g., average content per heading is at least 300 characters).\n\n## Instructions for Revisions\n- If modifications are needed, **call `reject`** and provide:\n  - A **clear reason** for rejection (e.g., \u201CDocument is 1,500 characters, below the 2,000-character minimum\u201D).\n  - **Detailed feedback** identifying the issue (e.g., \u201CSection [Section Title] is missing\u201D).\n  - **Specific suggestions** for correction (e.g., \u201CAdd 500 characters to Section [Section Title] with details on [specific topic]\u201D).\n- If the document is too short or lacks content:\n  - Compare the number of headings to the text length.\n  - Instruct the analyze agent to **expand content** within the current page (e.g., \u201CWith 5 headings and 1,500 characters, add 500 characters to Section [Section Title]\u201D).\n- If an internal anchor link points to a non-existent heading:\n  - Instruct the analyze agent to **create a new section** with the same title as the hyperlink and insert it under the appropriate heading.\n- If external document references are included in a non-table-of-contents page:\n  - Instruct the analyze agent to **integrate the referenced content** into the current page or remove the reference if it\u2019s not critical.\n- Requirements for revisions must follow the **EARS (Easy Approach to Requirements Syntax)** format.\n\n## Prohibited Actions\n- The Reviewer Agent **must not write content** under any circumstances.\n- Reviewers are **independent** and must not be instructed by other agents.\n- The Reviewer\u2019s words are **commands**, not recommendations, and must be followed.\n\n## Guidelines for Document Volume\n- Documents (excluding table of contents) should be **2,000\u20136,000 characters** for sufficient utility.\n- If the document is too short:\n  - Indicate the current character count and the additional characters needed (e.g., \u201CCurrent length: 1,500 characters; add 500 characters\u201D).\n  - Compare the number of headings to the text length and instruct the analyze agent to expand content accordingly (e.g., \u201CWith 5 headings, aim for 400 characters per heading\u201D).\n- The table of contents page is exempt from the volume limit.\n- When referencing the table of contents, **clearly state the section name**.\n\n## Guidelines for Hyperlinks\n- **Incomplete internal anchor links** (pointing to non-existent headings) trigger a `reject` call. Instruct the analyze agent to create the missing section.\n- **External document links** are allowed only if they do not impact the core content of the current document (unless it\u2019s a table of contents page). If they do, trigger a `reject` call and instruct integration or removal.\n- If a hyperlink points to a heading within the same document, that heading **must exist**. If it does not, call `reject` and instruct the analyze agent to add the section.\n- External links in non-table-of-contents pages that are not critical to the content are allowed, assuming other agents will handle those documents.\n\n## Q&A Guidelines\n- If the analyze agent asks a question, the Reviewer Agent **must answer** on behalf of the user.\n- **Never ask questions.** Only issue commands.\n\n## Review Completion Conditions\n- Call `accept` only when:\n  - All sections listed in the table of contents are **fully written**.\n  - All internal hyperlinks are **resolved** (point to existing headings).\n  - Document length is **2,000\u20136,000 characters** (excluding table of contents).\n  - External references (if any) do not impact the core content, or the document is a table of contents page.\n- If any sections are incomplete or links unresolved:\n  - Call `reject` and instruct the analyze agent to continue writing, specifying the **section title** and a **brief explanation** of the needed content (e.g., \u201CSection [Section Title] lacks details on [topic]; add 300 characters\u201D).\n\n## Iterative Review Workflow\n- If issues persist after revisions, **call `reject` again** with updated reasons, feedback, and suggestions.\n- Example: \u201CDocument is still 1,800 characters. Call `reject` and add 300 characters to Section [Section Title] with details on [specific topic].\u201D\n- Continue this process until all conditions for `accept` are met.\n\n## Additional Requirements for Page-Based Work Division\n- Each agent must write and review **only their assigned single page** out of the total pages specified.\n- If an agent attempts to request or create content beyond their assigned page, **immediately command them to focus solely on the current page.**\n- All document length and content sufficiency checks must be confined to the assigned page.\n- If multiple pages exist, the **exact number of pages** must be adhered to, and no additional pages should be created.\n- Enforce strict page-level division to maintain clear boundaries of responsibility and simplify review workflows.\n\n## Enforcement\n- All guidelines must be **strictly enforced**. Any violations (e.g., referencing other pages, insufficient content) require an immediate `reject` call with clear instructions for correction." /* AutoBeSystemPromptConstant.ANALYZE_REVIEWER */,
-        },
-    ];
-};
-exports.transformAnalyzeReviewerHistories = transformAnalyzeReviewerHistories;
-//# sourceMappingURL=transformAnalyzeReviewerHistories.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"transformAnalyzeReviewerHistories.js","sourceRoot":"","sources":["../../../src/orchestrate/analyze/transformAnalyzeReviewerHistories.ts"],"names":[],"mappings":";;;AACA,+BAA0B;AAInB,MAAM,iCAAiC,GAAG,CAAC,KAGjD,EAEC,EAAE;IACF,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,6BAA6B;gBAC7B,SAAS;gBACT,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC;gBAC3B,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,eAAe;YACrB,IAAI,6yQAA6C;SAClD;KACF,CAAC;AACJ,CAAC,CAAC;AAzBW,QAAA,iCAAiC,qCAyB5C"}

package/lib/orchestrate/analyze/transformAnalyzeWriteHistories.d.ts

@@ -1,12 +0,0 @@
-import { IAgenticaHistoryJson } from "@agentica/core";
-import { AutoBeAnalyzeRole } from "@autobe/interface";
-import { ILlmSchema } from "@samchon/openapi";
-import { AutoBeContext } from "../../context/AutoBeContext";
-import { IFile } from "./AutoBeAnalyzeFileSystem";
-export declare const transformAnalyzeWriteHistories: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, input: {
-    /** Total file names */
-    totalFiles: Pick<IFile, "filename" | "reason">[];
-    targetFile: string;
-    roles: AutoBeAnalyzeRole[];
-    review: string | null;
-}) => Array<IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage>;

package/lib/orchestrate/analyze/transformAnalyzeWriteHistories.js

@@ -1,78 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformAnalyzeWriteHistories = void 0;
-const uuid_1 = require("uuid");
-const transformAnalyzeWriteHistories = (ctx, input) => {
-    var _a, _b, _c;
-    return [
-        ...(input.review !== null
-            ? [
-                {
-                    id: (0, uuid_1.v4)(),
-                    created_at: new Date().toISOString(),
-                    type: "assistantMessage",
-                    text: [
-                        input.totalFiles.find((el) => el.filename === input.targetFile),
-                    ].join("\n"),
-                },
-                {
-                    id: (0, uuid_1.v4)(),
-                    created_at: new Date().toISOString(),
-                    type: "assistantMessage",
-                    text: [
-                        `You previously wrote a piece of content.`,
-                        `The following review has been received regarding your writing:`,
-                        input.review,
-                        `You must revise your content to reflect the feedback in this review.`,
-                    ].join(),
-                },
-            ]
-            : []),
-        {
-            id: (0, uuid_1.v4)(),
-            created_at: new Date().toISOString(),
-            type: "systemMessage",
-            text: "# Overview\nYou are the best planner.\nYou will write documents and hand it over to the developer.\nYou are only asked to fill out one document.\n\nLike revision_history.md, you should not write fakes for content that does not exist yet. If written, it is only allowed if there is a user's request directly.\n\nPlease converse with the user based on the following guidelines and example templates.  \nYou have to make a plan for the success of the user, and it has to be written in great detail to make the business successful.  \nYour performance is measured by your customer's success.  \nYou should listen to the reviewer and not make any requests to the reviewer.  \nIf the reviewer asks for changes, revise the entire document from top to bottom,\nincorporating both the existing content and the requested changes. Do not add only the new parts\u2014integrate them into a full rewrite of the document.  \nFor example, if you are asked to modify or expand 'internal_bulletin_board_service_plan.md',\ndo not create a document such as 'internal_bulletin_board_service_plan_expanded.md'.  \nonly update 'internal_bulletin_board_service_plan.md' file.  \n\nWrite a long document, but keep your answer short.\n\n# Number of documents that need to be created\nThe number of documents requested by the user, or the amount of documents sufficient for developers to develop\n\n# user information\n- user locale: {% User Locale %}\n\nCreate and review documents for your locale.\nIt must match the language of the user.\n\n# Documentation Style\nFor readability, even if the user requests it, a file should not exceed 3,000 characters. (The amount of text is measured in String(content).length)\nHyperlink features allow you to create more colorful documents.\n\nPlease make the file appropriate for user's language.\nDocuments and descriptions should be tailored to the language of the user.\n\nPlease refer to the document below. The document below has a total of 1,500 characters and should be longer.\nNever insert a question in the document.\n\nAny part of your documentation that can be written in EARS(Easy Approach to Requirements Syntax) must be written in EARS(Easy Approach to Requirements Syntax).\n\n\n## EARS Format Requirements\n\n- **EARS (Easy Approach to Requirements Syntax)** is a structured approach to writing requirements clearly and concisely, reducing ambiguity in software and system engineering. Requirements that can be expressed in EARS must use one of the following templates:  \n  - **Ubiquitous**: \"THE <system> SHALL <function>.\" (For always-applicable requirements, e.g., \"The system shall record all user inputs.\")  \n  - **Event-driven**: \"WHEN <trigger>, THE <system> SHALL <function>.\" (For event-triggered actions, e.g., \"When the user presses the 'Save' button, the system shall save the current document.\")  \n  - **State-driven**: \"WHILE <state>, THE <system> SHALL <function>.\" (For state-specific actions, e.g., \"While the system is in 'Idle' mode, the system shall display the main menu.\")  \n  - **Unwanted Behavior**: \"IF <condition>, THEN THE <system> SHALL <function>.\" (For handling undesirable situations, e.g., \"If the battery level is below 5%, then the system shall enter low-power mode.\")  \n  - **Optional Features**: \"WHERE <feature/condition>, THE <system> SHALL <function>.\" (For conditional features, e.g., \"Where the premium mode is activated, the system shall provide advanced analytics.\")  \n- **Instruct the analyze agent to use EARS for all applicable requirements, ensuring clarity, consistency, and testability.**  \n- If a requirement is ambiguous or not in EARS format when it could be, **command the analyze agent to rewrite it using the appropriate EARS template.**  \n- Ensure conditions, subjects, and actions in EARS-formatted requirements are specific and unambiguous.\n\n\n# abort\nIf you have no further requests or questions, immediately call the 'abort' function instead of replying with text. Never respond with additional text.\n\nWhen the reviewer determines the document is perfect and requires no more modifications, they must call the 'abort' function without hesitation.\n\n'abort' is a tool you must use to signal completion.\n\nDo not delay or avoid calling 'abort' once the document is complete.\n\nIf the reviewer says the document is complete but only one document out of multiple remains unfinished, do NOT call 'abort' yet.\n\nIf the reviewer requests creation or modification of any document other than the current assigned one, **ignore such requests** and continue focusing only on the current document.  \nIn this case, the reviewer may call 'abort' to forcibly terminate the review.\n\nWrite a long document, but keep your answer short." /* AutoBeSystemPromptConstant.ANALYZE */.replace("{% User Locale %}", (_b = (_a = ctx.config) === null || _a === void 0 ? void 0 : _a.locale) !== null && _b !== void 0 ? _b : "en-US"),
-        },
-        {
-            id: (0, uuid_1.v4)(),
-            created_at: new Date().toISOString(),
-            type: "systemMessage",
-            text: [
-                "# Guidelines",
-                "If the user specifies the exact number of pages, please follow it precisely.",
-                "You are the \u201CPlanning Expert (PlannerAgent)\u201D system agent.\nYou take full responsibility for all planning activities\u2014from product planning through requirements analysis, design, and documentation\u2014and you have extensive experience drafting planning documents.\n\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n1. Persona & Roles\n   \u2022 **Planning Expert**: Establish business objectives, craft user scenarios, and develop a strategic roadmap  \n   \u2022 **Communication Specialist**: Use a friendly yet professional tone, actively engaging with stakeholders  \n   \u2022 **Documentation Specialist**: Follow a structured approach (Table of Contents \u2192 Detailed TOC \u2192 Final Document) and deliver outputs in Markdown\n\n2. Conversation-Driven Extraction Framework (WHY \u2192 WHAT \u2192 HOW)\n   1. **WHY (Reason for the Problem)**\n      * \u201CWhy is this feature/project needed?\u201D \u201CWhat business or user problem does it solve?\u201D  \n      * Ask questions to clearly gather background, KPIs, and success criteria  \n   2. **WHAT (What to Solve)**\n      * \u201CWhat must be implemented?\u201D \u201CWhat are the key functional and non-functional requirements?\u201D  \n      * Distinguish between functional vs. non-functional, organize business requirements and user scenarios  \n   3. **HOW (How to Execute)**\n      * \u201CWhat flow and structure will the service follow?\u201D \u201CHow should the data model and ERD be designed?\u201D\n\n3. Scope & Constraints\n   \u2022 Do **not** produce development-level documentation (backend, frontend, or infrastructure tech stacks).  \n   \u2022 API design, database structure, and architecture reviews should be suggested only at a high level from a planning perspective\u2014avoid any detailed code or configuration references.\n\n4. Deliverable Structuring Guidelines\n   1. **Present the TOC First**\n      * Propose only the top-level Table of Contents initially; generate detailed sub-headings after user approval  \n      * When sub-TOCs grow large, split them into separate Markdown files and interlink them  \n   2. **Document Augmentation**\n      * Each document may be continuously updated; you may pre-link to future documents as placeholders  \n      * Only use links to actual, existing document paths\u2014external URLs that don\u2019t exist are prohibited  \n   3. **Document Components**\n      * Include: Overview, Objectives, User Personas, User Journeys, Functional & Non-Functional Requirements, Acceptance Criteria, ERD  \n      * Use tables, lists, and diagrams (ASCII or Mermaid) wherever helpful\n\n5. Communication & Feedback\n   \u2022 After each phase, summarize progress and ask for the user\u2019s confirmation (e.g., \u201CShall we proceed with this TOC?\u201D)  \n   \u2022 Upon completing a document: include a feedback prompt such as \u201CIs there anything else to refine?\u201D\n\n6. Final Deliverables\n   \u2022 Provide everything in Markdown (`.md`) format  \n   \u2022 Include inter-document reference links  \n   \u2022 Do **not** finalize the \u201Ccompleted\u201D version until the user has given explicit approval\n\n7. Review Loop\n   \u2022 Use a while-loop process: after drafting any part, send it to the review agent and iterate until they grant approval.  \n   \u2022 Do not advance to the next section until the review agent confirms the current one meets quality standards.\n\n8. Approval & File Generation\n   \u2022 Once the review agent approves the final draft, use the available tools to generate and export the document file.  \n\n9. Iterative Writing Flow\n   \u2022 Always start by proposing the top-level Table of Contents.  \n   \u2022 After TOC approval, draft the document one section (paragraph) at a time, submitting each for review before proceeding." /* AutoBeSystemPromptConstant.ANALYZE_GUIDELINE */,
-            ].join("\n"),
-        },
-        {
-            id: (0, uuid_1.v4)(),
-            created_at: new Date().toISOString(),
-            type: "systemMessage",
-            text: [
-                `# Instruction`,
-                `The names of all the files are as follows: ${input.totalFiles
-                    .map((f) => f.filename)
-                    .join(",")}`,
-                "Assume that all files are in the same folder. Also, when pointing to the location of a file, go to the relative path.",
-                "",
-                `The following user roles have been defined for this system:`,
-                ...input.roles.map((role) => `- ${role.name}: ${role.description}`),
-                "These roles will be used for API authentication and should be considered when creating documentation.",
-                "",
-                `Document Length Specification:`,
-                `- You are responsible for writing ONLY ONE document: ${input.targetFile}`,
-                `- Each page should contain approximately 2,000 characters`,
-                `- DO NOT write content for other documents - focus only on ${input.targetFile}`,
-                "",
-                `Among the various documents, the part you decided to take care of is as follows.: ${input.targetFile}`,
-                `Only write this document named '${input.targetFile}'.`,
-                "Never write other documents.",
-                "",
-                "# Reason to write this document",
-                `- ${(_c = input.totalFiles.find((el) => el.filename === input.targetFile)) === null || _c === void 0 ? void 0 : _c.reason}`,
-            ].join("\n"),
-        },
-    ];
-};
-exports.transformAnalyzeWriteHistories = transformAnalyzeWriteHistories;
-//# sourceMappingURL=transformAnalyzeWriteHistories.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"transformAnalyzeWriteHistories.js","sourceRoot":"","sources":["../../../src/orchestrate/analyze/transformAnalyzeWriteHistories.ts"],"names":[],"mappings":";;;AAGA,+BAA0B;AAMnB,MAAM,8BAA8B,GAAG,CAC5C,GAAyB,EACzB,KAMC,EAGD,EAAE;;IACF,OAAO;QACL,GAAG,CAAC,KAAK,CAAC,MAAM,KAAK,IAAI;YACvB,CAAC,CAAE;gBACC;oBACE,EAAE,EAAE,IAAA,SAAE,GAAE;oBACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;oBACpC,IAAI,EAAE,kBAAkB;oBACxB,IAAI,EAAE;wBACJ,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,QAAQ,KAAK,KAAK,CAAC,UAAU,CAAC;qBAChE,CAAC,IAAI,CAAC,IAAI,CAAC;iBACb;gBACD;oBACE,EAAE,EAAE,IAAA,SAAE,GAAE;oBACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;oBACpC,IAAI,EAAE,kBAAkB;oBACxB,IAAI,EAAE;wBACJ,0CAA0C;wBAC1C,gEAAgE;wBAChE,KAAK,CAAC,MAAM;wBACZ,sEAAsE;qBACvE,CAAC,IAAI,EAAE;iBACT;aACQ;YACb,CAAC,CAAC,EAAE,CAAC;QACP;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,eAAe;YACrB,IAAI,EAAE,wrJAAmC,OAAO,CAC9C,mBAAmB,EACnB,MAAA,MAAA,GAAG,CAAC,MAAM,0CAAE,MAAM,mCAAI,OAAO,CAC9B;SACF;QACD;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,eAAe;YACrB,IAAI,EAAE;gBACJ,cAAc;gBACd,8EAA8E;;aAE/E,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,eAAe;YACrB,IAAI,EAAE;gBACJ,eAAe;gBACf,8CAA8C,KAAK,CAAC,UAAU;qBAC3D,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC;qBACtB,IAAI,CAAC,GAAG,CAAC,EAAE;gBACd,uHAAuH;gBACvH,EAAE;gBACF,6DAA6D;gBAC7D,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC,WAAW,EAAE,CAAC;gBACnE,uGAAuG;gBACvG,EAAE;gBACF,gCAAgC;gBAChC,wDAAwD,KAAK,CAAC,UAAU,EAAE;gBAC1E,2DAA2D;gBAC3D,8DAA8D,KAAK,CAAC,UAAU,EAAE;gBAChF,EAAE;gBACF,qFAAqF,KAAK,CAAC,UAAU,EAAE;gBACvG,mCAAmC,KAAK,CAAC,UAAU,IAAI;gBACvD,8BAA8B;gBAC9B,EAAE;gBACF,iCAAiC;gBACjC,KAAK,MAAA,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,QAAQ,KAAK,KAAK,CAAC,UAAU,CAAC,0CAAE,MAAM,EAAE;aAC/E,CAAC,IAAI,CAAC,IAAI,CAAC;SACb;KACF,CAAC;AACJ,CAAC,CAAC;AApFW,QAAA,8BAA8B,kCAoFzC"}

package/lib/orchestrate/analyze/writeDocumentUntilReviewPassed.d.ts

@@ -1,16 +0,0 @@
-import { AutoBeAnalyzeRole } from "@autobe/interface";
-import { ILlmSchema } from "@samchon/openapi";
-import { AutoBeContext } from "../../context/AutoBeContext";
-import { IFile } from "./AutoBeAnalyzeFileSystem";
-import { AutoBeAnalyzePointer } from "./AutoBeAnalyzePointer";
-export declare function writeDocumentUntilReviewPassed<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, props: {
-    totalFiles: Pick<IFile, "filename" | "reason">[];
-    filename: string;
-    roles: AutoBeAnalyzeRole[];
-    progress: {
-        total: number;
-        completed: number;
-    };
-    retry?: number;
-    prevReview?: string;
-}): Promise<AutoBeAnalyzePointer>;