@autobe/agent 0.0.0 → 0.3.9

package/lib/orchestrate/prisma/orchestratePrismaSchema.js

@@ -0,0 +1,369 @@
+"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.orchestratePrismaSchemas = orchestratePrismaSchemas;
+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 transformPrismaSchemaHistories_1 = require("./transformPrismaSchemaHistories");
+function orchestratePrismaSchemas(ctx, components) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const start = new Date();
+        const entireTables = Array.from(new Set(components.flatMap((c) => c.tables)));
+        const total = components.reduce((acc, c) => acc + c.tables.length, 0);
+        let i = 0;
+        return yield Promise.all(components.map((c) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const result = yield process(ctx, {
+                filename: c.filename,
+                tables: c.tables,
+                entireTables,
+            });
+            const event = {
+                type: "prismaSchemas",
+                created_at: start.toISOString(),
+                filename: c.filename,
+                content: result.content,
+                completed: (i += c.tables.length),
+                total,
+                step: (_b = (_a = ctx.state().analyze) === null || _a === void 0 ? void 0 : _a.step) !== null && _b !== void 0 ? _b : 0,
+            };
+            ctx.dispatch(event);
+            return event;
+        })));
+    });
+}
+function process(ctx, component) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const pointer = {
+            value: null,
+        };
+        const agentica = new core_1.MicroAgentica({
+            model: ctx.model,
+            vendor: ctx.vendor,
+            config: Object.assign({}, ((_a = ctx.config) !== null && _a !== void 0 ? _a : {})),
+            histories: (0, transformPrismaSchemaHistories_1.transformPrismaSchemaHistories)(ctx.state()),
+            tokenUsage: ctx.usage(),
+            controllers: [
+                createApplication({
+                    model: ctx.model,
+                    build: (next) => {
+                        pointer.value = next;
+                    },
+                }),
+            ],
+        });
+        agentica.on("request", (event) => __awaiter(this, void 0, void 0, function* () {
+            if (event.body.tools) {
+                event.body.tool_choice = "required";
+            }
+        }));
+        yield agentica.conversate([
+            "Please generate Prisma schema files based on the previous requirement analysis report.",
+            "",
+            "**Context:**",
+            `- Target filename: \`${component.filename}\``,
+            `- Tables to implement in this file: \`${component.tables.join("`, `")}\``,
+            `- All available tables in the system: \`${component.entireTables.join("`, `")}\``,
+            "",
+            "**Instructions:**",
+            "1. Create comprehensive Prisma schema content for the specified tables",
+            "2. Reference the previous requirement analysis to understand business logic and data structures",
+            "3. Establish appropriate relationships between tables using the entireTables list as reference",
+            "4. Include proper field types, constraints, indexes, and documentation",
+            "5. Follow enterprise-level schema design patterns and best practices",
+            "6. Ensure cross-table relationships are accurately modeled based on business requirements",
+            "",
+            "**Key Requirements:**",
+            "- Implement only the tables specified for this file",
+            "- Create foreign key relationships to tables from entireTables when business logic requires it",
+            "- Add comprehensive field documentation and model descriptions",
+            "- Include appropriate indexes for performance optimization",
+            "- Follow consistent naming conventions and data types",
+        ].join("\n"));
+        if (pointer.value === null)
+            throw new Error("Unreachable code: Prisma Schema not generated");
+        return pointer.value;
+    });
+}
+function createApplication(props) {
+    (0, assertSchemaModel_1.assertSchemaModel)(props.model);
+    const application = collection[props.model];
+    return {
+        protocol: "class",
+        name: "Prisma Generator",
+        application,
+        execute: {
+            makePrismaSchemaFiles: (next) => {
+                props.build(next);
+            },
+        },
+    };
+}
+const claude = {
+    model: "claude",
+    options: {
+        reference: true,
+        separate: null
+    },
+    functions: [
+        {
+            name: "makePrismaSchemaFiles",
+            parameters: {
+                description: " Properties containing the complete set of Prisma schema files\n\n------------------------------\n\nCurrent Type: {@link IMakePrismaSchemaFilesProps}",
+                type: "object",
+                properties: {
+                    content: {
+                        title: "Complete Prisma schema content as a single concatenated string",
+                        description: "Complete Prisma schema content as a single concatenated string.\n\nContains all schema files organized by domain/functionality with clear file\nseparators. Each file section includes models, relationships, indexes, and\ncomprehensive documentation following enterprise patterns.\n\nContent should be organized following enterprise patterns:\n\n- Main.prisma: Configuration, datasource, and generators\n- Schema-XX-domain.prisma: Domain-specific entity definitions\n- Proper cross-file relationships and dependencies",
+                        type: "string"
+                    },
+                    description: {
+                        title: "Summary description of the application requirements and business context",
+                        description: "Summary description of the application requirements and business context.",
+                        type: "string"
+                    }
+                },
+                required: [
+                    "content",
+                    "description"
+                ],
+                additionalProperties: false,
+                $defs: {}
+            },
+            description: "Generates comprehensive Prisma schema files based on detailed requirements\nanalysis.\n\nCreates multiple organized schema files following enterprise patterns\nincluding proper domain separation, relationship modeling, snapshot\npatterns, inheritance, materialized views, and comprehensive documentation.\nThe generated schemas implement best practices for scalability,\nmaintainability, and data integrity.",
+            validate: (() => { const _io0 = input => "string" === typeof input.content && "string" === typeof input.description; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.content || _report(_exceptionable, {
+                    path: _path + ".content",
+                    expected: "string",
+                    value: input.content
+                }), "string" === typeof input.description || _report(_exceptionable, {
+                    path: _path + ".description",
+                    expected: "string",
+                    value: input.description
+                })].every(flag => flag); const __is = input => "object" === typeof input && null !== input && _io0(input); let errors; let _report; return input => {
+                if (false === __is(input)) {
+                    errors = [];
+                    _report = __typia_transform__validateReport._validateReport(errors);
+                    ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                        path: _path + "",
+                        expected: "IMakePrismaSchemaFilesProps",
+                        value: input
+                    })) && _vo0(input, _path + "", true) || _report(true, {
+                        path: _path + "",
+                        expected: "IMakePrismaSchemaFilesProps",
+                        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: "makePrismaSchemaFiles",
+                parameters: {
+                    description: " Properties containing the complete set of Prisma schema files\n\n------------------------------\n\nCurrent Type: {@link IMakePrismaSchemaFilesProps}",
+                    type: "object",
+                    properties: {
+                        content: {
+                            title: "Complete Prisma schema content as a single concatenated string",
+                            description: "Complete Prisma schema content as a single concatenated string.\n\nContains all schema files organized by domain/functionality with clear file\nseparators. Each file section includes models, relationships, indexes, and\ncomprehensive documentation following enterprise patterns.\n\nContent should be organized following enterprise patterns:\n\n- Main.prisma: Configuration, datasource, and generators\n- Schema-XX-domain.prisma: Domain-specific entity definitions\n- Proper cross-file relationships and dependencies",
+                            type: "string"
+                        },
+                        description: {
+                            title: "Summary description of the application requirements and business context",
+                            description: "Summary description of the application requirements and business context.",
+                            type: "string"
+                        }
+                    },
+                    required: [
+                        "content",
+                        "description"
+                    ],
+                    additionalProperties: false,
+                    $defs: {}
+                },
+                description: "Generates comprehensive Prisma schema files based on detailed requirements\nanalysis.\n\nCreates multiple organized schema files following enterprise patterns\nincluding proper domain separation, relationship modeling, snapshot\npatterns, inheritance, materialized views, and comprehensive documentation.\nThe generated schemas implement best practices for scalability,\nmaintainability, and data integrity.",
+                validate: (() => { const _io0 = input => "string" === typeof input.content && "string" === typeof input.description; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.content || _report(_exceptionable, {
+                        path: _path + ".content",
+                        expected: "string",
+                        value: input.content
+                    }), "string" === typeof input.description || _report(_exceptionable, {
+                        path: _path + ".description",
+                        expected: "string",
+                        value: input.description
+                    })].every(flag => flag); const __is = input => "object" === typeof input && null !== input && _io0(input); let errors; let _report; return input => {
+                    if (false === __is(input)) {
+                        errors = [];
+                        _report = __typia_transform__validateReport._validateReport(errors);
+                        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                            path: _path + "",
+                            expected: "IMakePrismaSchemaFilesProps",
+                            value: input
+                        })) && _vo0(input, _path + "", true) || _report(true, {
+                            path: _path + "",
+                            expected: "IMakePrismaSchemaFilesProps",
+                            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,
+    "3.0": {
+        model: "3.0",
+        options: {
+            constraint: true,
+            recursive: 3,
+            separate: null
+        },
+        functions: [
+            {
+                name: "makePrismaSchemaFiles",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        content: {
+                            type: "string",
+                            title: "Complete Prisma schema content as a single concatenated string",
+                            description: "Complete Prisma schema content as a single concatenated string.\n\nContains all schema files organized by domain/functionality with clear file\nseparators. Each file section includes models, relationships, indexes, and\ncomprehensive documentation following enterprise patterns.\n\nContent should be organized following enterprise patterns:\n\n- Main.prisma: Configuration, datasource, and generators\n- Schema-XX-domain.prisma: Domain-specific entity definitions\n- Proper cross-file relationships and dependencies"
+                        },
+                        description: {
+                            type: "string",
+                            title: "Summary description of the application requirements and business context",
+                            description: "Summary description of the application requirements and business context."
+                        }
+                    },
+                    required: [
+                        "content",
+                        "description"
+                    ],
+                    description: " Properties containing the complete set of Prisma schema files\n\n------------------------------\n\nCurrent Type: {@link IMakePrismaSchemaFilesProps}",
+                    additionalProperties: false
+                },
+                description: "Generates comprehensive Prisma schema files based on detailed requirements\nanalysis.\n\nCreates multiple organized schema files following enterprise patterns\nincluding proper domain separation, relationship modeling, snapshot\npatterns, inheritance, materialized views, and comprehensive documentation.\nThe generated schemas implement best practices for scalability,\nmaintainability, and data integrity.",
+                validate: (() => { const _io0 = input => "string" === typeof input.content && "string" === typeof input.description; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.content || _report(_exceptionable, {
+                        path: _path + ".content",
+                        expected: "string",
+                        value: input.content
+                    }), "string" === typeof input.description || _report(_exceptionable, {
+                        path: _path + ".description",
+                        expected: "string",
+                        value: input.description
+                    })].every(flag => flag); const __is = input => "object" === typeof input && null !== input && _io0(input); let errors; let _report; return input => {
+                    if (false === __is(input)) {
+                        errors = [];
+                        _report = __typia_transform__validateReport._validateReport(errors);
+                        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                            path: _path + "",
+                            expected: "IMakePrismaSchemaFilesProps",
+                            value: input
+                        })) && _vo0(input, _path + "", true) || _report(true, {
+                            path: _path + "",
+                            expected: "IMakePrismaSchemaFilesProps",
+                            value: input
+                        }))(input, "$input", true);
+                        const success = 0 === errors.length;
+                        return success ? {
+                            success,
+                            data: input
+                        } : {
+                            success,
+                            errors,
+                            data: input
+                        };
+                    }
+                    return {
+                        success: true,
+                        data: input
+                    };
+                }; })()
+            }
+        ]
+    },
+};
+//# sourceMappingURL=orchestratePrismaSchema.js.map

package/lib/orchestrate/prisma/orchestratePrismaSchema.js.map

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

package/lib/orchestrate/prisma/transformPrismaCompilerHistories.d.ts

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

package/lib/orchestrate/prisma/transformPrismaCompilerHistories.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformPrismaCompilerHistories = void 0;
+const transformPrismaCompilerHistories = (state, files) => {
+    if (state.analyze === null)
+        return [
+            {
+                type: "systemMessage",
+                text: [
+                    "Requirement analysis is not yet completed.",
+                    "Don't call any tool function,",
+                    "but say to process the requirement analysis.",
+                ].join(" "),
+            },
+        ];
+    return [
+        {
+            type: "systemMessage",
+            text: "You are a world-class Prisma schema validation and error resolution specialist. You excel at analyzing Prisma compilation errors and providing precise fixes while maintaining schema integrity and design principles.\n\n### Core Principles\n\n- **Never ask for clarification** - Analyze errors and provide direct solutions\n- **Output only corrected schema** - Return Record<string, string> format with fixes applied\n- **Preserve original intent** - Fix errors while maintaining the original design and relationships\n- **Maintain consistency** - Ensure fixes don't break other parts of the schema\n\n### Default Working Language: English\n\n- Use the language specified by user in messages as the working language when explicitly provided\n- All analysis and responses must be in the working language\n- All model/field names must remain in English regardless of working language\n\n### Input Format\n\nYou will receive:\n1. **Original schema files** - Record<string, string> format from Schema Agent\n2. **Compilation errors** - Detailed error messages from Prisma compiler\n3. **Original requirements** - User requirements for context (optional)\n\n### Task: Fix Prisma Compilation Errors\n\nAnalyze compilation errors and provide corrected schema files that resolve all issues while maintaining the original design intent.\n\n### Error Analysis Process\n\n1. **Error Classification**: Categorize each error by type and severity\n2. **Root Cause Analysis**: Identify the underlying cause of each error\n3. **Impact Assessment**: Determine how fixes might affect other parts of the schema\n4. **Solution Design**: Plan fixes that resolve errors while preserving functionality\n5. **Validation**: Ensure fixes don't introduce new errors\n\n### Common Error Types and Solutions\n\n#### Relationship Errors\n- **Missing models**: Create referenced models or update references\n- **Invalid field mappings**: Correct field names and types in @relation\n- **Circular dependencies**: Restructure relationships to avoid cycles\n- **Missing foreign keys**: Add required foreign key fields\n\n#### Type and Constraint Errors\n- **Invalid data types**: Correct to supported Prisma types\n- **Missing constraints**: Add required @id, @unique, or other constraints\n- **Invalid attribute usage**: Fix attribute syntax and placement\n\n#### Naming and Syntax Errors\n- **Reserved keywords**: Rename fields that conflict with Prisma/DB keywords\n- **Invalid identifiers**: Fix naming to follow Prisma conventions\n- **Syntax errors**: Correct Prisma schema syntax\n\n#### Cross-File Reference Errors\n- **Model not found**: Ensure referenced models exist in the correct files\n- **Circular imports**: Restructure file dependencies\n- **Invalid field references**: Update references to match actual field names\n\n### Fix Strategy Guidelines\n\n#### Minimal Changes Principle\n- Make the smallest changes necessary to fix errors\n- Preserve original model structure and relationships\n- Maintain field names and types where possible\n\n#### Consistency Maintenance\n- Ensure naming conventions remain consistent\n- Preserve comment structure and quality\n- Maintain architectural patterns (snapshot-based, etc.)\n\n#### Relationship Integrity\n- Ensure all relationships remain bidirectional where intended\n- Preserve cascade behaviors and constraints\n- Maintain foreign key relationships\n\n### Expected Output Format\n\n```json\n{\n  \"main.prisma\": \"// Fixed version with corrected generator/datasource\\ngenerator client {\\n  provider = \\\"prisma-client-js\\\"\\n}\\n\\ndatasource db {\\n  provider = \\\"postgresql\\\"\\n  url = env(\\\"DATABASE_URL\\\")\\n}\",\n  \"schema-01-core.prisma\": \"// Fixed version with corrected relationships\\nmodel users {\\n  // ... corrected model with fixes applied\\n}\",\n  \"schema-02-articles.prisma\": \"// Fixed version with resolved dependencies\\nmodel articles {\\n  // ... corrected model with fixes applied\\n}\"\n}\n```\n\n### Validation Checklist\n\nAfter applying fixes, ensure:\n- [ ] All compilation errors are resolved\n- [ ] No new errors are introduced\n- [ ] Relationships remain properly mapped\n- [ ] Foreign keys are correctly defined\n- [ ] Model and field names follow conventions\n- [ ] Comments and documentation are preserved\n- [ ] Cross-file references are valid\n- [ ] Original design intent is maintained\n\n### Error Reporting\n\nIf errors cannot be resolved without significant design changes:\n- Identify the specific errors that require design decisions\n- Suggest alternative approaches\n- Explain the trade-offs of different solutions\n- Provide the best possible fix with clear documentation of changes made" /* AutoBeSystemPromptConstant.PRISMA_COMPILER */,
+        },
+        {
+            type: "assistantMessage",
+            text: [
+                "Below are the current schema files that failed compilation:",
+                "",
+                "============================================== CURRENT SCHEMA FILES ==============================================",
+                "",
+                Object.entries(files)
+                    .map(([filename, content]) => {
+                    return [
+                        `// =============================================================================`,
+                        `// FILE: ${filename}`,
+                        `// =============================================================================`,
+                        content,
+                    ].join("\n");
+                })
+                    .join("\n\n"),
+                "",
+            ].join("\n"),
+        },
+    ];
+};
+exports.transformPrismaCompilerHistories = transformPrismaCompilerHistories;
+//# sourceMappingURL=transformPrismaCompilerHistories.js.map

package/lib/orchestrate/prisma/transformPrismaCompilerHistories.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformPrismaCompilerHistories.js","sourceRoot":"","sources":["../../../src/orchestrate/prisma/transformPrismaCompilerHistories.ts"],"names":[],"mappings":";;;AAKO,MAAM,gCAAgC,GAAG,CAC9C,KAAkB,EAClB,KAA6B,EAG7B,EAAE;IACF,IAAI,KAAK,CAAC,OAAO,KAAK,IAAI;QACxB,OAAO;YACL;gBACE,IAAI,EAAE,eAAe;gBACrB,IAAI,EAAE;oBACJ,4CAA4C;oBAC5C,+BAA+B;oBAC/B,8CAA8C;iBAC/C,CAAC,IAAI,CAAC,GAAG,CAAC;aACZ;SACF,CAAC;IACJ,OAAO;QACL;YACE,IAAI,EAAE,eAAe;YACrB,IAAI,2nJAA4C;SACjD;QACD;YACE,IAAI,EAAE,kBAAkB;YACxB,IAAI,EAAE;gBACJ,6DAA6D;gBAC7D,EAAE;gBACF,oHAAoH;gBACpH,EAAE;gBACF,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC;qBAClB,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,OAAO,CAAC,EAAE,EAAE;oBAC3B,OAAO;wBACL,kFAAkF;wBAClF,YAAY,QAAQ,EAAE;wBACtB,kFAAkF;wBAClF,OAAO;qBACR,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBACf,CAAC,CAAC;qBACD,IAAI,CAAC,MAAM,CAAC;gBACf,EAAE;aACH,CAAC,IAAI,CAAC,IAAI,CAAC;SACb;KACF,CAAC;AACJ,CAAC,CAAC;AA3CW,QAAA,gCAAgC,oCA2C3C"}

package/lib/orchestrate/prisma/transformPrismaComponentsHistories.d.ts

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

package/lib/orchestrate/prisma/transformPrismaComponentsHistories.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformPrismaComponentsHistories = void 0;
+const transformPrismaComponentsHistories = (state) => {
+    if (state.analyze === null)
+        return [
+            {
+                type: "systemMessage",
+                text: [
+                    "Requirement analysis is not yet completed.",
+                    "Don't call any tool function,",
+                    "but say to process the requirement analysis.",
+                ].join(" "),
+            },
+        ];
+    return [
+        {
+            type: "systemMessage",
+            text: "You are a world-class database architecture analyst specializing in domain-driven design and schema organization. You excel at analyzing requirements and organizing database models into logical, maintainable file structures.\n\n### Core Principles\n\n- **Never ask for clarification** - Work with the provided requirements and make reasonable assumptions\n- **Output only structured JSON** - Return organized file-table mappings in the specified format\n- **Follow domain-driven design** - Group related entities into cohesive domains\n- **Prioritize logical separation** - Ensure clear boundaries between different business domains\n\n### Default Working Language: English\n\n- Use the language specified by user in messages as the working language when explicitly provided\n- All thinking and analysis must be in the working language\n- All model/table names must be in English regardless of working language\n\n### Task: Analyze Requirements and Generate File Structure\n\nYour primary task is to analyze user requirements and generate a structured file organization plan in the format: `{filename: string; tables: string[]}[]`\n\n### Analysis Steps\n\n1. **Domain Analysis**: Identify distinct business domains from requirements\n2. **Entity Identification**: Extract all entities/models mentioned or implied\n3. **Relationship Mapping**: Understand how entities relate across domains\n4. **File Organization**: Group related entities into logical files\n5. **Validation**: Ensure all entities are accounted for and properly grouped\n\n### File Organization Guidelines\n\n#### Naming Conventions\n\n- **Filenames**: `schema-{number}-{domain}.prisma` (e.g., `schema-01-core.prisma`, `schema-02-users.prisma`)\n- **Main config**: Always include `main.prisma` for datasource/generator configuration\n- **Domain names**: Use clear, descriptive domain names in snake_case\n\n#### Grouping Strategy\n\n- **Core/Foundation**: Basic entities used across multiple domains (users, organizations)\n- **Domain-specific**: Entities belonging to specific business domains\n- **Cross-cutting**: Entities that span multiple domains (notifications, audit logs)\n- **Utility**: Helper entities (settings, configurations)\n\n#### File Structure Rules\n\n- **Maximum 8-10 models per file** for maintainability\n- **Related entities together**: Keep strongly related models in the same file\n- **Dependency consideration**: Place foundational models in earlier files\n- **Logical progression**: Order files from core to specific domains\n\n### Expected Output Format\n\n```json\n[\n  {\n    \"filename\": \"main.prisma\",\n    \"tables\": []\n  },\n  {\n    \"filename\": \"schema-01-core.prisma\", \n    \"tables\": [\"users\", \"user_profiles\", \"organizations\"]\n  },\n  {\n    \"filename\": \"schema-02-articles.prisma\",\n    \"tables\": [\"articles\", \"article_snapshots\", \"article_comments\"]\n  }\n]\n```\n\n### Quality Checklist\n\nBefore outputting, ensure:\n- [ ] All entities from requirements are included\n- [ ] Files are logically organized by domain\n- [ ] No single file is overloaded with too many models\n- [ ] Dependencies flow from core to specific domains\n- [ ] Filename conventions are followed\n- [ ] main.prisma is included for configuration" /* AutoBeSystemPromptConstant.PRISMA_COMPONENT */,
+        },
+        {
+            type: "assistantMessage",
+            text: [
+                "Here is the requirement analysis report.",
+                "",
+                "Call the provided tool function to generate Prisma DB schema",
+                "referencing below requirement analysis report.",
+                "",
+                "## User Request",
+                state.analyze.reason,
+                "",
+                `## Requirement Analysis Report`,
+                "",
+                "```json",
+                JSON.stringify(state.analyze.files),
+                "```",
+            ].join("\n"),
+        },
+    ];
+};
+exports.transformPrismaComponentsHistories = transformPrismaComponentsHistories;
+//# sourceMappingURL=transformPrismaComponentsHistories.js.map

package/lib/orchestrate/prisma/transformPrismaComponentsHistories.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformPrismaComponentsHistories.js","sourceRoot":"","sources":["../../../src/orchestrate/prisma/transformPrismaComponentsHistories.ts"],"names":[],"mappings":";;;AAKO,MAAM,kCAAkC,GAAG,CAChD,KAAkB,EAGlB,EAAE;IACF,IAAI,KAAK,CAAC,OAAO,KAAK,IAAI;QACxB,OAAO;YACL;gBACE,IAAI,EAAE,eAAe;gBACrB,IAAI,EAAE;oBACJ,4CAA4C;oBAC5C,+BAA+B;oBAC/B,8CAA8C;iBAC/C,CAAC,IAAI,CAAC,GAAG,CAAC;aACZ;SACF,CAAC;IACJ,OAAO;QACL;YACE,IAAI,EAAE,eAAe;YACrB,IAAI,6uGAA6C;SAClD;QACD;YACE,IAAI,EAAE,kBAAkB;YACxB,IAAI,EAAE;gBACJ,0CAA0C;gBAC1C,EAAE;gBACF,8DAA8D;gBAC9D,gDAAgD;gBAChD,EAAE;gBACF,iBAAiB;gBACjB,KAAK,CAAC,OAAO,CAAC,MAAM;gBACpB,EAAE;gBACF,gCAAgC;gBAChC,EAAE;gBACF,SAAS;gBACT,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;gBACnC,KAAK;aACN,CAAC,IAAI,CAAC,IAAI,CAAC;SACb;KACF,CAAC;AACJ,CAAC,CAAC;AAxCW,QAAA,kCAAkC,sCAwC7C"}

package/lib/orchestrate/prisma/transformPrismaHistories.d.ts

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