@autobe/agent 0.17.1 → 0.18.0

package/lib/{orchestrate → agent/src/orchestrate}/prisma/orchestratePrismaComponent.js

@@ -47,42 +47,31 @@ var __importDefault = (this && this.__importDefault) || function (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("./histories/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, _e, _f;
+    return __awaiter(this, arguments, void 0, function* (ctx, message = "Please extract files and tables from the given documents.") {
+        var _a, _b, _c, _d, _e;
         const start = new Date();
         const pointer = {
             value: null,
         };
         const prefix = (_b = (_a = ctx.state().analyze) === null || _a === void 0 ? void 0 : _a.prefix) !== null && _b !== void 0 ? _b : null;
-        const agentica = new core_1.MicroAgentica({
-            model: ctx.model,
-            vendor: ctx.vendor,
-            config: Object.assign(Object.assign({}, ((_c = ctx.config) !== null && _c !== void 0 ? _c : {})), { executor: {
-                    describe: null,
-                } }),
+        const { histories, tokenUsage } = yield ctx.conversate({
+            source: "prismaComponents",
             histories: (0, transformPrismaComponentsHistories_1.transformPrismaComponentsHistories)(ctx.state(), prefix),
-            controllers: [
-                createApplication({
-                    model: ctx.model,
-                    build: (next) => {
-                        pointer.value = next;
-                    },
-                }),
-            ],
-        });
-        const histories = yield agentica
-            .conversate(content)
-            .finally(() => {
-            const tokenUsage = agentica.getTokenUsage().aggregate;
-            ctx.usage().record(tokenUsage, ["prisma"]);
+            controller: createController({
+                model: ctx.model,
+                build: (next) => {
+                    pointer.value = next;
+                },
+            }),
+            enforceFunctionCall: false,
+            message,
         });
-        if (((_d = histories.at(-1)) === null || _d === void 0 ? void 0 : _d.type) === "assistantMessage")
+        if (((_c = histories.at(-1)) === null || _c === void 0 ? void 0 : _c.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
@@ -94,11 +83,12 @@ function orchestratePrismaComponents(ctx_1) {
             review: pointer.value.review,
             decision: pointer.value.decision,
             components: pointer.value.components,
-            step: (_f = (_e = ctx.state().analyze) === null || _e === void 0 ? void 0 : _e.step) !== null && _f !== void 0 ? _f : 0,
+            tokenUsage,
+            step: (_e = (_d = ctx.state().analyze) === null || _d === void 0 ? void 0 : _d.step) !== null && _e !== void 0 ? _e : 0,
         };
     });
 }
-function createApplication(props) {
+function createController(props) {
     (0, assertSchemaModel_1.assertSchemaModel)(props.model);
     const application = collection[props.model];
     return {
@@ -142,7 +132,8 @@ const claude = {
                         type: "array",
                         items: {
                             $ref: "#/$defs/AutoBePrisma.IComponent"
-                        }
+                        },
+                        minItems: 1
                     }
                 },
                 required: [
@@ -200,7 +191,7 @@ const claude = {
                 }
             },
             description: "Organizes database tables into domain-based components for Prisma schema\ngeneration.\n\nTakes business requirements and groups related tables into logical domains,\nwith each component becoming a separate .prisma file.",
-            validate: (() => { const _io0 = input => "string" === typeof input.thinking && "string" === typeof input.review && "string" === typeof input.decision && (Array.isArray(input.components) && input.components.every(elem => "object" === typeof elem && null !== elem && _io1(elem))); const _io1 = input => "string" === typeof input.filename && RegExp("^[a-zA-Z0-9._-]+\\.prisma$").test(input.filename) && "string" === typeof input.namespace && "string" === typeof input.thinking && "string" === typeof input.review && "string" === typeof input.rationale && (Array.isArray(input.tables) && (1 <= input.tables.length && input.tables.every(elem => "string" === typeof elem && RegExp("^[a-z][a-z0-9_]*$").test(elem)))); const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.thinking || _report(_exceptionable, {
+            validate: (() => { const _io0 = input => "string" === typeof input.thinking && "string" === typeof input.review && "string" === typeof input.decision && (Array.isArray(input.components) && (1 <= input.components.length && input.components.every(elem => "object" === typeof elem && null !== elem && _io1(elem)))); const _io1 = input => "string" === typeof input.filename && RegExp("^[a-zA-Z0-9._-]+\\.prisma$").test(input.filename) && "string" === typeof input.namespace && "string" === typeof input.thinking && "string" === typeof input.review && "string" === typeof input.rationale && (Array.isArray(input.tables) && (1 <= input.tables.length && input.tables.every(elem => "string" === typeof elem && RegExp("^[a-z][a-z0-9_]*$").test(elem)))); const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.thinking || _report(_exceptionable, {
                     path: _path + ".thinking",
                     expected: "string",
                     value: input.thinking
@@ -214,7 +205,11 @@ const claude = {
                     value: input.decision
                 }), (Array.isArray(input.components) || _report(_exceptionable, {
                     path: _path + ".components",
-                    expected: "Array<AutoBePrisma.IComponent>",
+                    expected: "(Array<AutoBePrisma.IComponent> & MinItems<1>)",
+                    value: input.components
+                })) && ((1 <= input.components.length || _report(_exceptionable, {
+                    path: _path + ".components",
+                    expected: "Array<> & MinItems<1>",
                     value: input.components
                 })) && input.components.map((elem, _index3) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
                     path: _path + ".components[" + _index3 + "]",
@@ -224,9 +219,9 @@ const claude = {
                     path: _path + ".components[" + _index3 + "]",
                     expected: "AutoBePrisma.IComponent",
                     value: elem
-                })).every(flag => flag) || _report(_exceptionable, {
+                })).every(flag => flag)) || _report(_exceptionable, {
                     path: _path + ".components",
-                    expected: "Array<AutoBePrisma.IComponent>",
+                    expected: "(Array<AutoBePrisma.IComponent> & MinItems<1>)",
                     value: input.components
                 })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.filename && (RegExp("^[a-zA-Z0-9._-]+\\.prisma$").test(input.filename) || _report(_exceptionable, {
                     path: _path + ".filename",
@@ -254,7 +249,7 @@ const claude = {
                     value: input.rationale
                 }), (Array.isArray(input.tables) || _report(_exceptionable, {
                     path: _path + ".tables",
-                    expected: "(Array<string & Pattern<\"^[a-z][a-z0-9_]*$\">> & MinItems<1>)",
+                    expected: "(Array<string & SnakePattern> & MinItems<1>)",
                     value: input.tables
                 })) && ((1 <= input.tables.length || _report(_exceptionable, {
                     path: _path + ".tables",
@@ -262,15 +257,15 @@ const claude = {
                     value: input.tables
                 })) && input.tables.map((elem, _index4) => "string" === typeof elem && (RegExp("^[a-z][a-z0-9_]*$").test(elem) || _report(_exceptionable, {
                     path: _path + ".tables[" + _index4 + "]",
-                    expected: "string & Pattern<\"^[a-z][a-z0-9_]*$\">",
+                    expected: "string & SnakePattern",
                     value: elem
                 })) || _report(_exceptionable, {
                     path: _path + ".tables[" + _index4 + "]",
-                    expected: "(string & Pattern<\"^[a-z][a-z0-9_]*$\">)",
+                    expected: "(string & SnakePattern)",
                     value: elem
                 })).every(flag => flag)) || _report(_exceptionable, {
                     path: _path + ".tables",
-                    expected: "(Array<string & Pattern<\"^[a-z][a-z0-9_]*$\">> & MinItems<1>)",
+                    expected: "(Array<string & SnakePattern> & MinItems<1>)",
                     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)) {
@@ -331,7 +326,7 @@ const collection = {
                             type: "string"
                         },
                         components: {
-                            description: "Array of domain components that group related database tables.\n\nEach component represents a business domain and becomes one Prisma schema\nfile. Common domains include: Actors (users), Sales (products), Orders,\nCarts, etc.\n\n**Example:**\n\n```typescript\n{\n  \"components\": [\n    {\n      \"filename\": \"schema-02-systematic.prisma\",\n      \"namespace\": \"Systematic\",\n      \"thinking\": \"These tables all relate to system configuration and channel management. They form the foundation of the platform.\",\n      \"review\": \"Considering the relationships, shopping_channel_categories connects channels and sales, but it fundamentally defines channel structure.\",\n      \"rationale\": \"Grouping all system configuration tables together provides a clear foundation layer that other domains can reference.\",\n      \"tables\": [\n        \"shopping_channels\",\n        \"shopping_sections\",\n        \"shopping_channel_categories\"\n      ]\n    },\n    {\n      \"filename\": \"schema-03-actors.prisma\",\n      \"namespace\": \"Actors\",\n      \"thinking\": \"All user-related entities should be grouped together as they share authentication and identity patterns.\",\n      \"review\": \"While customers interact with sales, the customer entity itself is about identity, not transactions.\",\n      \"rationale\": \"This component groups all actor-related tables to maintain separation between identity management and business transactions.\",\n      \"tables\": [\n        \"shopping_customers\",\n        \"shopping_citizens\",\n        \"shopping_administrators\"\n      ]\n    },\n    {\n      \"filename\": \"schema-04-sales.prisma\",\n      \"namespace\": \"Sales\",\n      \"thinking\": \"Product catalog and sales-related tables belong together as they form the core commerce functionality.\",\n      \"review\": \"Sales snapshots are integral to the sales domain for tracking product history and price changes.\",\n      \"rationale\": \"Consolidating all sales-related tables enables coherent management of the entire product lifecycle.\",\n      \"tables\": [\n        \"shopping_sales\",\n        \"shopping_sale_snapshots\",\n        \"shopping_sale_units\",\n        \"shopping_sale_unit_options\"\n      ]\n    }\n  ]\n}\n```\n\n**Notes:**\n\n- Table names must follow snake_case convention with domain prefix (e.g.,\n  `shopping_customers`)\n- Each component becomes one `.prisma` file containing related models\n- Filename numbering indicates dependency order for schema generation\n- Namespace is used for documentation organization and domain grouping",
+                            description: "Array of domain components that group related database tables.\n\nEach component represents a business domain and becomes one Prisma schema\nfile. Common domains include: Actors (users), Sales (products), Orders,\nCarts, etc.\n\n**Example:**\n\n```typescript\n{\n  \"components\": [\n    {\n      \"filename\": \"schema-02-systematic.prisma\",\n      \"namespace\": \"Systematic\",\n      \"thinking\": \"These tables all relate to system configuration and channel management. They form the foundation of the platform.\",\n      \"review\": \"Considering the relationships, shopping_channel_categories connects channels and sales, but it fundamentally defines channel structure.\",\n      \"rationale\": \"Grouping all system configuration tables together provides a clear foundation layer that other domains can reference.\",\n      \"tables\": [\n        \"shopping_channels\",\n        \"shopping_sections\",\n        \"shopping_channel_categories\"\n      ]\n    },\n    {\n      \"filename\": \"schema-03-actors.prisma\",\n      \"namespace\": \"Actors\",\n      \"thinking\": \"All user-related entities should be grouped together as they share authentication and identity patterns.\",\n      \"review\": \"While customers interact with sales, the customer entity itself is about identity, not transactions.\",\n      \"rationale\": \"This component groups all actor-related tables to maintain separation between identity management and business transactions.\",\n      \"tables\": [\n        \"shopping_customers\",\n        \"shopping_citizens\",\n        \"shopping_administrators\"\n      ]\n    },\n    {\n      \"filename\": \"schema-04-sales.prisma\",\n      \"namespace\": \"Sales\",\n      \"thinking\": \"Product catalog and sales-related tables belong together as they form the core commerce functionality.\",\n      \"review\": \"Sales snapshots are integral to the sales domain for tracking product history and price changes.\",\n      \"rationale\": \"Consolidating all sales-related tables enables coherent management of the entire product lifecycle.\",\n      \"tables\": [\n        \"shopping_sales\",\n        \"shopping_sale_snapshots\",\n        \"shopping_sale_units\",\n        \"shopping_sale_unit_options\"\n      ]\n    }\n  ]\n}\n```\n\n**Notes:**\n\n- Table names must follow snake_case convention with domain prefix (e.g.,\n  `shopping_customers`)\n- Each component becomes one `.prisma` file containing related models\n- Filename numbering indicates dependency order for schema generation\n- Namespace is used for documentation organization and domain grouping\n\n\n@minItems 1",
                             type: "array",
                             items: {
                                 $ref: "#/$defs/AutoBePrisma.IComponent"
@@ -391,7 +386,7 @@ const collection = {
                     }
                 },
                 description: "Organizes database tables into domain-based components for Prisma schema\ngeneration.\n\nTakes business requirements and groups related tables into logical domains,\nwith each component becoming a separate .prisma file.",
-                validate: (() => { const _io0 = input => "string" === typeof input.thinking && "string" === typeof input.review && "string" === typeof input.decision && (Array.isArray(input.components) && input.components.every(elem => "object" === typeof elem && null !== elem && _io1(elem))); const _io1 = input => "string" === typeof input.filename && RegExp("^[a-zA-Z0-9._-]+\\.prisma$").test(input.filename) && "string" === typeof input.namespace && "string" === typeof input.thinking && "string" === typeof input.review && "string" === typeof input.rationale && (Array.isArray(input.tables) && (1 <= input.tables.length && input.tables.every(elem => "string" === typeof elem && RegExp("^[a-z][a-z0-9_]*$").test(elem)))); const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.thinking || _report(_exceptionable, {
+                validate: (() => { const _io0 = input => "string" === typeof input.thinking && "string" === typeof input.review && "string" === typeof input.decision && (Array.isArray(input.components) && (1 <= input.components.length && input.components.every(elem => "object" === typeof elem && null !== elem && _io1(elem)))); const _io1 = input => "string" === typeof input.filename && RegExp("^[a-zA-Z0-9._-]+\\.prisma$").test(input.filename) && "string" === typeof input.namespace && "string" === typeof input.thinking && "string" === typeof input.review && "string" === typeof input.rationale && (Array.isArray(input.tables) && (1 <= input.tables.length && input.tables.every(elem => "string" === typeof elem && RegExp("^[a-z][a-z0-9_]*$").test(elem)))); const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.thinking || _report(_exceptionable, {
                         path: _path + ".thinking",
                         expected: "string",
                         value: input.thinking
@@ -405,7 +400,11 @@ const collection = {
                         value: input.decision
                     }), (Array.isArray(input.components) || _report(_exceptionable, {
                         path: _path + ".components",
-                        expected: "Array<AutoBePrisma.IComponent>",
+                        expected: "(Array<AutoBePrisma.IComponent> & MinItems<1>)",
+                        value: input.components
+                    })) && ((1 <= input.components.length || _report(_exceptionable, {
+                        path: _path + ".components",
+                        expected: "Array<> & MinItems<1>",
                         value: input.components
                     })) && input.components.map((elem, _index3) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
                         path: _path + ".components[" + _index3 + "]",
@@ -415,9 +414,9 @@ const collection = {
                         path: _path + ".components[" + _index3 + "]",
                         expected: "AutoBePrisma.IComponent",
                         value: elem
-                    })).every(flag => flag) || _report(_exceptionable, {
+                    })).every(flag => flag)) || _report(_exceptionable, {
                         path: _path + ".components",
-                        expected: "Array<AutoBePrisma.IComponent>",
+                        expected: "(Array<AutoBePrisma.IComponent> & MinItems<1>)",
                         value: input.components
                     })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.filename && (RegExp("^[a-zA-Z0-9._-]+\\.prisma$").test(input.filename) || _report(_exceptionable, {
                         path: _path + ".filename",
@@ -445,7 +444,7 @@ const collection = {
                         value: input.rationale
                     }), (Array.isArray(input.tables) || _report(_exceptionable, {
                         path: _path + ".tables",
-                        expected: "(Array<string & Pattern<\"^[a-z][a-z0-9_]*$\">> & MinItems<1>)",
+                        expected: "(Array<string & SnakePattern> & MinItems<1>)",
                         value: input.tables
                     })) && ((1 <= input.tables.length || _report(_exceptionable, {
                         path: _path + ".tables",
@@ -453,15 +452,15 @@ const collection = {
                         value: input.tables
                     })) && input.tables.map((elem, _index4) => "string" === typeof elem && (RegExp("^[a-z][a-z0-9_]*$").test(elem) || _report(_exceptionable, {
                         path: _path + ".tables[" + _index4 + "]",
-                        expected: "string & Pattern<\"^[a-z][a-z0-9_]*$\">",
+                        expected: "string & SnakePattern",
                         value: elem
                     })) || _report(_exceptionable, {
                         path: _path + ".tables[" + _index4 + "]",
-                        expected: "(string & Pattern<\"^[a-z][a-z0-9_]*$\">)",
+                        expected: "(string & SnakePattern)",
                         value: elem
                     })).every(flag => flag)) || _report(_exceptionable, {
                         path: _path + ".tables",
-                        expected: "(Array<string & Pattern<\"^[a-z][a-z0-9_]*$\">> & MinItems<1>)",
+                        expected: "(Array<string & SnakePattern> & MinItems<1>)",
                         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)) {

package/lib/agent/src/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/agent/src/orchestrate/prisma/orchestratePrismaCorrect.d.ts

@@ -0,0 +1,4 @@
+import { AutoBePrisma, IAutoBePrismaValidation } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../context/AutoBeContext";
+export declare function orchestratePrismaCorrect<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, application: AutoBePrisma.IApplication, life?: number): Promise<IAutoBePrismaValidation>;