@autobe/agent 0.0.0 → 0.3.6

package/lib/orchestrate/prisma/orchestratePrismaComponent.js

@@ -0,0 +1,437 @@
+"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.orchestratePrismaComponents = orchestratePrismaComponents;
+const __typia_transform__validateReport = __importStar(require("typia/lib/internal/_validateReport.js"));
+const core_1 = require("@agentica/core");
+const typia_1 = __importDefault(require("typia"));
+const uuid_1 = require("uuid");
+const assertSchemaModel_1 = require("../../context/assertSchemaModel");
+const transformPrismaComponentsHistories_1 = require("./transformPrismaComponentsHistories");
+function orchestratePrismaComponents(ctx_1) {
+    return __awaiter(this, arguments, void 0, function* (ctx, content = "Please extract files and tables from the given documents.") {
+        var _a, _b, _c, _d;
+        const start = new Date();
+        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, transformPrismaComponentsHistories_1.transformPrismaComponentsHistories)(ctx.state()),
+            tokenUsage: ctx.usage(),
+            controllers: [
+                createApplication({
+                    model: ctx.model,
+                    build: (next) => {
+                        pointer.value = next;
+                    },
+                }),
+            ],
+        });
+        const histories = yield agentica.conversate(content);
+        if (((_b = histories.at(-1)) === null || _b === void 0 ? void 0 : _b.type) === "assistantMessage")
+            return Object.assign(Object.assign({}, histories.at(-1)), { created_at: start.toISOString(), completed_at: new Date().toISOString(), id: (0, uuid_1.v4)() });
+        else if (pointer.value === null) {
+            throw new Error("Failed to extract files and tables."); // unreachable
+        }
+        return {
+            type: "prismaComponents",
+            created_at: start.toISOString(),
+            components: pointer.value.components,
+            step: (_d = (_c = ctx.state().analyze) === null || _c === void 0 ? void 0 : _c.step) !== null && _d !== void 0 ? _d : 0,
+        };
+    });
+}
+function createApplication(props) {
+    (0, assertSchemaModel_1.assertSchemaModel)(props.model);
+    const application = collection[props.model];
+    return {
+        protocol: "class",
+        name: "Prisma Extract Files and Tables",
+        application,
+        execute: {
+            extractComponents: (next) => {
+                props.build(next);
+            },
+        },
+    };
+}
+const claude = {
+    model: "claude",
+    options: {
+        reference: true,
+        separate: null
+    },
+    functions: [
+        {
+            name: "extractComponents",
+            parameters: {
+                description: " - Configuration object containing the file-to-table mapping\nstructure\n\n------------------------------\n\nCurrent Type: {@link IExtractComponentsProps}",
+                type: "object",
+                properties: {
+                    components: {
+                        title: "Maps Prisma schema filenames to their contained database tables",
+                        description: "Maps Prisma schema filenames to their contained database tables.\n\n**Structure:**\n\n- Key: Prisma schema filename with .prisma extension\n- Value: Array of table names defined in that file\n\n**Example:**\n\n```typescript\n{\n  {\n    filename: \"schema-01-users.prisma\",\n    tables: [\"user\", \"user_profile\", \"user_settings\"]\n  },\n  {\n    filename: \"schema-02-articles.prisma\",\n    tables: [\"article\", \"article_snapshot\"]\n  },\n  {\n    filename: \"schema-03-comments.prisma\",\n    tables: [\"comment\", \"comment_like\"]\n  }\n}\n```\n\n**Notes:**\n\n- Table names must match exact Prisma model names (case-sensitive)\n- Keep mapping synchronized with actual schema files\n- Use consistent naming convention for files",
+                        type: "array",
+                        items: {
+                            description: "Current Type: {@link IComponent}",
+                            type: "object",
+                            properties: {
+                                filename: {
+                                    type: "string"
+                                },
+                                tables: {
+                                    type: "array",
+                                    items: {
+                                        type: "string"
+                                    }
+                                }
+                            },
+                            required: [
+                                "filename",
+                                "tables"
+                            ]
+                        }
+                    }
+                },
+                required: [
+                    "components"
+                ],
+                additionalProperties: false,
+                $defs: {}
+            },
+            description: "Extracts and organizes database schema files with their corresponding table\ndefinitions.\n\nProcesses Prisma schema files and maps each file to its contained database\ntables, enabling structured organization of schemas across multiple files\nfor large projects.",
+            validate: (() => { const _io0 = input => Array.isArray(input.components) && input.components.every(elem => "object" === typeof elem && null !== elem && _io1(elem)); const _io1 = input => "string" === typeof input.filename && (Array.isArray(input.tables) && input.tables.every(elem => "string" === typeof elem)); const _vo0 = (input, _path, _exceptionable = true) => [(Array.isArray(input.components) || _report(_exceptionable, {
+                    path: _path + ".components",
+                    expected: "Array<IComponent>",
+                    value: input.components
+                })) && input.components.map((elem, _index3) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                    path: _path + ".components[" + _index3 + "]",
+                    expected: "IComponent",
+                    value: elem
+                })) && _vo1(elem, _path + ".components[" + _index3 + "]", true && _exceptionable) || _report(_exceptionable, {
+                    path: _path + ".components[" + _index3 + "]",
+                    expected: "IComponent",
+                    value: elem
+                })).every(flag => flag) || _report(_exceptionable, {
+                    path: _path + ".components",
+                    expected: "Array<IComponent>",
+                    value: input.components
+                })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.filename || _report(_exceptionable, {
+                    path: _path + ".filename",
+                    expected: "string",
+                    value: input.filename
+                }), (Array.isArray(input.tables) || _report(_exceptionable, {
+                    path: _path + ".tables",
+                    expected: "Array<string>",
+                    value: input.tables
+                })) && input.tables.map((elem, _index4) => "string" === typeof elem || _report(_exceptionable, {
+                    path: _path + ".tables[" + _index4 + "]",
+                    expected: "string",
+                    value: elem
+                })).every(flag => flag) || _report(_exceptionable, {
+                    path: _path + ".tables",
+                    expected: "Array<string>",
+                    value: input.tables
+                })].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: "IExtractComponentsProps",
+                        value: input
+                    })) && _vo0(input, _path + "", true) || _report(true, {
+                        path: _path + "",
+                        expected: "IExtractComponentsProps",
+                        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: "extractComponents",
+                parameters: {
+                    description: " - Configuration object containing the file-to-table mapping\nstructure\n\n------------------------------\n\nCurrent Type: {@link IExtractComponentsProps}",
+                    type: "object",
+                    properties: {
+                        components: {
+                            title: "Maps Prisma schema filenames to their contained database tables",
+                            description: "Maps Prisma schema filenames to their contained database tables.\n\n**Structure:**\n\n- Key: Prisma schema filename with .prisma extension\n- Value: Array of table names defined in that file\n\n**Example:**\n\n```typescript\n{\n  {\n    filename: \"schema-01-users.prisma\",\n    tables: [\"user\", \"user_profile\", \"user_settings\"]\n  },\n  {\n    filename: \"schema-02-articles.prisma\",\n    tables: [\"article\", \"article_snapshot\"]\n  },\n  {\n    filename: \"schema-03-comments.prisma\",\n    tables: [\"comment\", \"comment_like\"]\n  }\n}\n```\n\n**Notes:**\n\n- Table names must match exact Prisma model names (case-sensitive)\n- Keep mapping synchronized with actual schema files\n- Use consistent naming convention for files",
+                            type: "array",
+                            items: {
+                                description: "Current Type: {@link IComponent}",
+                                type: "object",
+                                properties: {
+                                    filename: {
+                                        type: "string"
+                                    },
+                                    tables: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        }
+                                    }
+                                },
+                                required: [
+                                    "filename",
+                                    "tables"
+                                ]
+                            }
+                        }
+                    },
+                    required: [
+                        "components"
+                    ],
+                    additionalProperties: false,
+                    $defs: {}
+                },
+                description: "Extracts and organizes database schema files with their corresponding table\ndefinitions.\n\nProcesses Prisma schema files and maps each file to its contained database\ntables, enabling structured organization of schemas across multiple files\nfor large projects.",
+                validate: (() => { const _io0 = input => Array.isArray(input.components) && input.components.every(elem => "object" === typeof elem && null !== elem && _io1(elem)); const _io1 = input => "string" === typeof input.filename && (Array.isArray(input.tables) && input.tables.every(elem => "string" === typeof elem)); const _vo0 = (input, _path, _exceptionable = true) => [(Array.isArray(input.components) || _report(_exceptionable, {
+                        path: _path + ".components",
+                        expected: "Array<IComponent>",
+                        value: input.components
+                    })) && input.components.map((elem, _index3) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".components[" + _index3 + "]",
+                        expected: "IComponent",
+                        value: elem
+                    })) && _vo1(elem, _path + ".components[" + _index3 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".components[" + _index3 + "]",
+                        expected: "IComponent",
+                        value: elem
+                    })).every(flag => flag) || _report(_exceptionable, {
+                        path: _path + ".components",
+                        expected: "Array<IComponent>",
+                        value: input.components
+                    })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.filename || _report(_exceptionable, {
+                        path: _path + ".filename",
+                        expected: "string",
+                        value: input.filename
+                    }), (Array.isArray(input.tables) || _report(_exceptionable, {
+                        path: _path + ".tables",
+                        expected: "Array<string>",
+                        value: input.tables
+                    })) && input.tables.map((elem, _index4) => "string" === typeof elem || _report(_exceptionable, {
+                        path: _path + ".tables[" + _index4 + "]",
+                        expected: "string",
+                        value: elem
+                    })).every(flag => flag) || _report(_exceptionable, {
+                        path: _path + ".tables",
+                        expected: "Array<string>",
+                        value: input.tables
+                    })].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: "IExtractComponentsProps",
+                            value: input
+                        })) && _vo0(input, _path + "", true) || _report(true, {
+                            path: _path + "",
+                            expected: "IExtractComponentsProps",
+                            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: "extractComponents",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        components: {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    filename: {
+                                        type: "string"
+                                    },
+                                    tables: {
+                                        type: "array",
+                                        items: {
+                                            type: "string"
+                                        }
+                                    }
+                                },
+                                required: [
+                                    "filename",
+                                    "tables"
+                                ],
+                                description: "Current Type: {@link IComponent}",
+                                additionalProperties: false
+                            },
+                            title: "Maps Prisma schema filenames to their contained database tables",
+                            description: "Maps Prisma schema filenames to their contained database tables.\n\n**Structure:**\n\n- Key: Prisma schema filename with .prisma extension\n- Value: Array of table names defined in that file\n\n**Example:**\n\n```typescript\n{\n  {\n    filename: \"schema-01-users.prisma\",\n    tables: [\"user\", \"user_profile\", \"user_settings\"]\n  },\n  {\n    filename: \"schema-02-articles.prisma\",\n    tables: [\"article\", \"article_snapshot\"]\n  },\n  {\n    filename: \"schema-03-comments.prisma\",\n    tables: [\"comment\", \"comment_like\"]\n  }\n}\n```\n\n**Notes:**\n\n- Table names must match exact Prisma model names (case-sensitive)\n- Keep mapping synchronized with actual schema files\n- Use consistent naming convention for files"
+                        }
+                    },
+                    required: [
+                        "components"
+                    ],
+                    description: " - Configuration object containing the file-to-table mapping\nstructure\n\n------------------------------\n\nCurrent Type: {@link IExtractComponentsProps}",
+                    additionalProperties: false
+                },
+                description: "Extracts and organizes database schema files with their corresponding table\ndefinitions.\n\nProcesses Prisma schema files and maps each file to its contained database\ntables, enabling structured organization of schemas across multiple files\nfor large projects.",
+                validate: (() => { const _io0 = input => Array.isArray(input.components) && input.components.every(elem => "object" === typeof elem && null !== elem && _io1(elem)); const _io1 = input => "string" === typeof input.filename && (Array.isArray(input.tables) && input.tables.every(elem => "string" === typeof elem)); const _vo0 = (input, _path, _exceptionable = true) => [(Array.isArray(input.components) || _report(_exceptionable, {
+                        path: _path + ".components",
+                        expected: "Array<IComponent>",
+                        value: input.components
+                    })) && input.components.map((elem, _index3) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+                        path: _path + ".components[" + _index3 + "]",
+                        expected: "IComponent",
+                        value: elem
+                    })) && _vo1(elem, _path + ".components[" + _index3 + "]", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".components[" + _index3 + "]",
+                        expected: "IComponent",
+                        value: elem
+                    })).every(flag => flag) || _report(_exceptionable, {
+                        path: _path + ".components",
+                        expected: "Array<IComponent>",
+                        value: input.components
+                    })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.filename || _report(_exceptionable, {
+                        path: _path + ".filename",
+                        expected: "string",
+                        value: input.filename
+                    }), (Array.isArray(input.tables) || _report(_exceptionable, {
+                        path: _path + ".tables",
+                        expected: "Array<string>",
+                        value: input.tables
+                    })) && input.tables.map((elem, _index4) => "string" === typeof elem || _report(_exceptionable, {
+                        path: _path + ".tables[" + _index4 + "]",
+                        expected: "string",
+                        value: elem
+                    })).every(flag => flag) || _report(_exceptionable, {
+                        path: _path + ".tables",
+                        expected: "Array<string>",
+                        value: input.tables
+                    })].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: "IExtractComponentsProps",
+                            value: input
+                        })) && _vo0(input, _path + "", true) || _report(true, {
+                            path: _path + "",
+                            expected: "IExtractComponentsProps",
+                            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=orchestratePrismaComponent.js.map

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

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

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

@@ -0,0 +1,7 @@
+import { AutoBePrismaSchemasEvent } from "@autobe/interface/src/events/AutoBePrismaSchemasEvent";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../context/AutoBeContext";
+export declare function orchestratePrismaSchemas<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, components: {
+    filename: string;
+    tables: string[];
+}[]): Promise<AutoBePrismaSchemasEvent[]>;