@autobe/agent 0.5.2 → 0.7.0

package/lib/orchestrate/test/orchestrateTestProgress.js

@@ -0,0 +1,403 @@
+"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.orchestrateTestProgress = orchestrateTestProgress;
+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 transformTestProgressHistories_1 = require("./transformTestProgressHistories");
+function orchestrateTestProgress(ctx, scenarios) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const start = new Date();
+        let complete = 0;
+        const events = yield Promise.all(
+        /**
+         * Generate test code for each scenario. Maps through scenarios array to
+         * create individual test code implementations. Each scenario is processed
+         * to generate corresponding test code and progress events.
+         */
+        scenarios.map((scenario) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const code = yield process(ctx, scenario);
+            const event = {
+                type: "testProgress",
+                created_at: start.toISOString(),
+                filename: `${code.domain}/${scenario.functionName}.ts`,
+                content: code.content,
+                completed: ++complete,
+                total: scenarios.length,
+                step: (_b = (_a = ctx.state().interface) === null || _a === void 0 ? void 0 : _a.step) !== null && _b !== void 0 ? _b : 0,
+            };
+            ctx.dispatch(event);
+            return event;
+        })));
+        return events;
+    });
+}
+/**
+ * Process function that generates test code for each individual scenario. Takes
+ * the AutoBeContext and scenario information as input and uses MicroAgentica to
+ * generate appropriate test code through LLM interaction.
+ *
+ * @param ctx - The AutoBeContext containing model, vendor and configuration
+ * @param scenario - The test scenario information to generate code for
+ * @returns Promise resolving to ICreateTestCodeProps containing the generated
+ *   test code
+ */
+function process(ctx, scenario) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e;
+        const pointer = {
+            value: null,
+        };
+        const apiFiles = Object.entries((_b = (_a = ctx.state().interface) === null || _a === void 0 ? void 0 : _a.files) !== null && _b !== void 0 ? _b : {})
+            .filter(([filename]) => {
+            return filename.startsWith("src/api/");
+        })
+            .reduce((acc, [filename, content]) => {
+            return Object.assign(acc, { [filename]: content });
+        }, {});
+        const dtoFiles = Object.entries((_d = (_c = ctx.state().interface) === null || _c === void 0 ? void 0 : _c.files) !== null && _d !== void 0 ? _d : {})
+            .filter(([filename]) => {
+            return filename.startsWith("src/api/structures/");
+        })
+            .reduce((acc, [filename, content]) => {
+            return Object.assign(acc, { [filename]: content });
+        }, {});
+        const agentica = new core_1.MicroAgentica({
+            model: ctx.model,
+            vendor: ctx.vendor,
+            config: Object.assign({}, ((_e = ctx.config) !== null && _e !== void 0 ? _e : {})),
+            histories: (0, transformTestProgressHistories_1.transformTestProgressHistories)(apiFiles, dtoFiles),
+            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([
+            "Create test code for below scenario:",
+            "",
+            "```json",
+            JSON.stringify(scenario, null, 2),
+            "```",
+        ].join("\n"));
+        if (pointer.value === null)
+            throw new Error("Failed to create test code.");
+        return pointer.value;
+    });
+}
+function createApplication(props) {
+    (0, assertSchemaModel_1.assertSchemaModel)(props.model);
+    const application = collection[props.model];
+    return {
+        protocol: "class",
+        name: "Create Test Code",
+        application,
+        execute: {
+            createTestCode: (next) => {
+                props.build(next);
+            },
+        },
+    };
+}
+const claude = {
+    model: "claude",
+    options: {
+        reference: true,
+        separate: null
+    },
+    functions: [
+        {
+            name: "createTestCode",
+            parameters: {
+                description: "Current Type: {@link ICreateTestCodeProps}",
+                type: "object",
+                properties: {
+                    plan: {
+                        title: "Strategic approach for test implementation",
+                        description: "Strategic approach for test implementation.\n\nDefine the high-level strategy and logical flow for testing the given\nscenario. Focus on test methodology, data preparation, and assertion\nstrategy.\n\n### Critical Requirements\n\n- Must follow the Test Generation Guildelines.\n- Must Planning the test code Never occur the typescript compile error.\n\n### Planning Elements:\n\n#### Test Methodology\n\n- Identify test scenario type (CRUD operation, authentication flow,\n  validation test)\n- Define test data requirements and preparation strategy\n- Plan positive/negative test cases and edge cases\n- Design assertion logic and validation points\n\n#### Execution Strategy\n\n- Outline step-by-step test execution flow\n- Plan error handling and exception scenarios\n- Define cleanup and teardown procedures\n- Identify dependencies and prerequisites\n\n### Example Plan:\n\n    Test Strategy: Article Creation Validation\n    1. Prepare valid article data with required fields\n    2. Execute POST request to create article\n    3. Validate response structure and data integrity\n    4. Test error scenarios (missing fields, invalid data)\n    5. Verify database state changes\n    6. Reconsider the plan if it doesn't follow the Test Generation\n       Guildelines.",
+                        type: "string"
+                    },
+                    domain: {
+                        title: "Functional domain classification for test organization",
+                        description: "Functional domain classification for test organization.\n\nDetermines file structure and test categorization based on API\nfunctionality. Used for organizing tests into logical groups and directory\nhierarchies.\n\n### Naming Rules:\n\n- Lowercase English words only\n- Singular nouns (e.g., \"article\", \"user\", \"comment\")\n- Kebab-case for compound words (e.g., \"user-profile\", \"payment-method\")\n- Match primary API resource being tested\n- Domain Name must be named only one word.\n\n### Domain Examples:\n\n- `article` \u2192 Article management operations\n- `comment` \u2192 Comment-related functionality\n- `auth` \u2192 Authentication and authorization\n- `user` \u2192 User management operations\n- `payment` \u2192 Payment processing\n- `notification` \u2192 Notification system",
+                        type: "string"
+                    },
+                    content: {
+                        title: "Complete TypeScript E2E test implementation",
+                        description: "Complete TypeScript E2E test implementation.\n\nGenerate fully functional, compilation-error-free test code following",
+                        type: "string"
+                    }
+                },
+                required: [
+                    "plan",
+                    "domain",
+                    "content"
+                ],
+                additionalProperties: false,
+                $defs: {}
+            },
+            validate: (() => { const _io0 = input => "string" === typeof input.plan && "string" === typeof input.domain && "string" === typeof input.content; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.plan || _report(_exceptionable, {
+                    path: _path + ".plan",
+                    expected: "string",
+                    value: input.plan
+                }), "string" === typeof input.domain || _report(_exceptionable, {
+                    path: _path + ".domain",
+                    expected: "string",
+                    value: input.domain
+                }), "string" === typeof input.content || _report(_exceptionable, {
+                    path: _path + ".content",
+                    expected: "string",
+                    value: input.content
+                })].every(flag => flag); const __is = input => "object" === typeof input && null !== input && _io0(input); let errors; let _report; return input => {
+                if (false === __is(input)) {
+                    errors = [];
+                    _report = __typia_transform__validateReport._validateReport(errors);
+                    ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                        path: _path + "",
+                        expected: "ICreateTestCodeProps",
+                        value: input
+                    })) && _vo0(input, _path + "", true) || _report(true, {
+                        path: _path + "",
+                        expected: "ICreateTestCodeProps",
+                        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: "createTestCode",
+                parameters: {
+                    description: "Current Type: {@link ICreateTestCodeProps}",
+                    type: "object",
+                    properties: {
+                        plan: {
+                            title: "Strategic approach for test implementation",
+                            description: "Strategic approach for test implementation.\n\nDefine the high-level strategy and logical flow for testing the given\nscenario. Focus on test methodology, data preparation, and assertion\nstrategy.\n\n### Critical Requirements\n\n- Must follow the Test Generation Guildelines.\n- Must Planning the test code Never occur the typescript compile error.\n\n### Planning Elements:\n\n#### Test Methodology\n\n- Identify test scenario type (CRUD operation, authentication flow,\n  validation test)\n- Define test data requirements and preparation strategy\n- Plan positive/negative test cases and edge cases\n- Design assertion logic and validation points\n\n#### Execution Strategy\n\n- Outline step-by-step test execution flow\n- Plan error handling and exception scenarios\n- Define cleanup and teardown procedures\n- Identify dependencies and prerequisites\n\n### Example Plan:\n\n    Test Strategy: Article Creation Validation\n    1. Prepare valid article data with required fields\n    2. Execute POST request to create article\n    3. Validate response structure and data integrity\n    4. Test error scenarios (missing fields, invalid data)\n    5. Verify database state changes\n    6. Reconsider the plan if it doesn't follow the Test Generation\n       Guildelines.",
+                            type: "string"
+                        },
+                        domain: {
+                            title: "Functional domain classification for test organization",
+                            description: "Functional domain classification for test organization.\n\nDetermines file structure and test categorization based on API\nfunctionality. Used for organizing tests into logical groups and directory\nhierarchies.\n\n### Naming Rules:\n\n- Lowercase English words only\n- Singular nouns (e.g., \"article\", \"user\", \"comment\")\n- Kebab-case for compound words (e.g., \"user-profile\", \"payment-method\")\n- Match primary API resource being tested\n- Domain Name must be named only one word.\n\n### Domain Examples:\n\n- `article` \u2192 Article management operations\n- `comment` \u2192 Comment-related functionality\n- `auth` \u2192 Authentication and authorization\n- `user` \u2192 User management operations\n- `payment` \u2192 Payment processing\n- `notification` \u2192 Notification system",
+                            type: "string"
+                        },
+                        content: {
+                            title: "Complete TypeScript E2E test implementation",
+                            description: "Complete TypeScript E2E test implementation.\n\nGenerate fully functional, compilation-error-free test code following",
+                            type: "string"
+                        }
+                    },
+                    required: [
+                        "plan",
+                        "domain",
+                        "content"
+                    ],
+                    additionalProperties: false,
+                    $defs: {}
+                },
+                validate: (() => { const _io0 = input => "string" === typeof input.plan && "string" === typeof input.domain && "string" === typeof input.content; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.plan || _report(_exceptionable, {
+                        path: _path + ".plan",
+                        expected: "string",
+                        value: input.plan
+                    }), "string" === typeof input.domain || _report(_exceptionable, {
+                        path: _path + ".domain",
+                        expected: "string",
+                        value: input.domain
+                    }), "string" === typeof input.content || _report(_exceptionable, {
+                        path: _path + ".content",
+                        expected: "string",
+                        value: input.content
+                    })].every(flag => flag); const __is = input => "object" === typeof input && null !== input && _io0(input); let errors; let _report; return input => {
+                    if (false === __is(input)) {
+                        errors = [];
+                        _report = __typia_transform__validateReport._validateReport(errors);
+                        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                            path: _path + "",
+                            expected: "ICreateTestCodeProps",
+                            value: input
+                        })) && _vo0(input, _path + "", true) || _report(true, {
+                            path: _path + "",
+                            expected: "ICreateTestCodeProps",
+                            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: "createTestCode",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        plan: {
+                            type: "string",
+                            title: "Strategic approach for test implementation",
+                            description: "Strategic approach for test implementation.\n\nDefine the high-level strategy and logical flow for testing the given\nscenario. Focus on test methodology, data preparation, and assertion\nstrategy.\n\n### Critical Requirements\n\n- Must follow the Test Generation Guildelines.\n- Must Planning the test code Never occur the typescript compile error.\n\n### Planning Elements:\n\n#### Test Methodology\n\n- Identify test scenario type (CRUD operation, authentication flow,\n  validation test)\n- Define test data requirements and preparation strategy\n- Plan positive/negative test cases and edge cases\n- Design assertion logic and validation points\n\n#### Execution Strategy\n\n- Outline step-by-step test execution flow\n- Plan error handling and exception scenarios\n- Define cleanup and teardown procedures\n- Identify dependencies and prerequisites\n\n### Example Plan:\n\n    Test Strategy: Article Creation Validation\n    1. Prepare valid article data with required fields\n    2. Execute POST request to create article\n    3. Validate response structure and data integrity\n    4. Test error scenarios (missing fields, invalid data)\n    5. Verify database state changes\n    6. Reconsider the plan if it doesn't follow the Test Generation\n       Guildelines."
+                        },
+                        domain: {
+                            type: "string",
+                            title: "Functional domain classification for test organization",
+                            description: "Functional domain classification for test organization.\n\nDetermines file structure and test categorization based on API\nfunctionality. Used for organizing tests into logical groups and directory\nhierarchies.\n\n### Naming Rules:\n\n- Lowercase English words only\n- Singular nouns (e.g., \"article\", \"user\", \"comment\")\n- Kebab-case for compound words (e.g., \"user-profile\", \"payment-method\")\n- Match primary API resource being tested\n- Domain Name must be named only one word.\n\n### Domain Examples:\n\n- `article` \u2192 Article management operations\n- `comment` \u2192 Comment-related functionality\n- `auth` \u2192 Authentication and authorization\n- `user` \u2192 User management operations\n- `payment` \u2192 Payment processing\n- `notification` \u2192 Notification system"
+                        },
+                        content: {
+                            type: "string",
+                            title: "Complete TypeScript E2E test implementation",
+                            description: "Complete TypeScript E2E test implementation.\n\nGenerate fully functional, compilation-error-free test code following"
+                        }
+                    },
+                    required: [
+                        "plan",
+                        "domain",
+                        "content"
+                    ],
+                    description: "Current Type: {@link ICreateTestCodeProps}",
+                    additionalProperties: false
+                },
+                validate: (() => { const _io0 = input => "string" === typeof input.plan && "string" === typeof input.domain && "string" === typeof input.content; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.plan || _report(_exceptionable, {
+                        path: _path + ".plan",
+                        expected: "string",
+                        value: input.plan
+                    }), "string" === typeof input.domain || _report(_exceptionable, {
+                        path: _path + ".domain",
+                        expected: "string",
+                        value: input.domain
+                    }), "string" === typeof input.content || _report(_exceptionable, {
+                        path: _path + ".content",
+                        expected: "string",
+                        value: input.content
+                    })].every(flag => flag); const __is = input => "object" === typeof input && null !== input && _io0(input); let errors; let _report; return input => {
+                    if (false === __is(input)) {
+                        errors = [];
+                        _report = __typia_transform__validateReport._validateReport(errors);
+                        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                            path: _path + "",
+                            expected: "ICreateTestCodeProps",
+                            value: input
+                        })) && _vo0(input, _path + "", true) || _report(true, {
+                            path: _path + "",
+                            expected: "ICreateTestCodeProps",
+                            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=orchestrateTestProgress.js.map

package/lib/orchestrate/test/orchestrateTestProgress.js.map

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

package/lib/orchestrate/test/orchestrateTestScenario.d.ts

@@ -0,0 +1,4 @@
+import { AutoBeTestScenarioEvent } from "@autobe/interface/src/events/AutoBeTestScenarioEvent";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../context/AutoBeContext";
+export declare function orchestrateTestScenario<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>): Promise<AutoBeTestScenarioEvent>;