@autobe/agent 0.16.1 → 0.18.0

package/lib/agent/src/orchestrate/test/orchestrateTestScenario.js.map

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

package/lib/agent/src/orchestrate/test/orchestrateTestWrite.d.ts

@@ -0,0 +1,5 @@
+import { AutoBeTestScenario } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { IAutoBeTestWriteResult } from "./structures/IAutoBeTestWriteResult";
+export declare function orchestrateTestWrite<Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, scenarios: AutoBeTestScenario[]): Promise<IAutoBeTestWriteResult[]>;

package/lib/{orchestrate → agent/src/orchestrate}/test/orchestrateTestWrite.js

@@ -47,18 +47,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.orchestrateTestWrite = orchestrateTestWrite;
 const __typia_transform__validateReport = __importStar(require("typia/lib/internal/_validateReport.js"));
-const core_1 = require("@agentica/core");
 const typia_1 = __importDefault(require("typia"));
 const assertSchemaModel_1 = require("../../context/assertSchemaModel");
-const enforceToolCall_1 = require("../../utils/enforceToolCall");
-const forceRetry_1 = require("../../utils/forceRetry");
 const completeTestCode_1 = require("./compile/completeTestCode");
 const getTestScenarioArtifacts_1 = require("./compile/getTestScenarioArtifacts");
-const transformTestWriteHistories_1 = require("./transformTestWriteHistories");
+const transformTestWriteHistories_1 = require("./histories/transformTestWriteHistories");
 function orchestrateTestWrite(ctx, scenarios) {
     return __awaiter(this, void 0, void 0, function* () {
-        const start = new Date();
-        let complete = 0;
+        const progress = {
+            total: scenarios.length,
+            completed: 0,
+        };
         const result = yield Promise.all(
         /**
          * Generate test code for each scenario. Maps through plans array to create
@@ -67,19 +66,14 @@ function orchestrateTestWrite(ctx, scenarios) {
          */
         scenarios.map((scenario) => __awaiter(this, void 0, void 0, function* () {
             try {
-                const r = yield (0, forceRetry_1.forceRetry)(() => __awaiter(this, void 0, void 0, function* () {
-                    var _a, _b;
-                    const artifacts = yield (0, getTestScenarioArtifacts_1.getTestScenarioArtifacts)(ctx, scenario);
-                    const result = yield process(ctx, scenario, artifacts);
-                    const event = Object.assign(Object.assign({ type: "testWrite", created_at: start.toISOString(), location: `test/features/api/${result.domain}/${scenario.functionName}.ts` }, result), { 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 {
-                        scenario,
-                        artifacts,
-                        event,
-                    };
-                }));
-                return r;
+                const artifacts = yield (0, getTestScenarioArtifacts_1.getTestScenarioArtifacts)(ctx, scenario);
+                const event = yield process(ctx, scenario, artifacts, progress);
+                ctx.dispatch(event);
+                return {
+                    scenario,
+                    artifacts,
+                    event,
+                };
             }
             catch (_a) {
                 return null;
@@ -96,43 +90,34 @@ function orchestrateTestWrite(ctx, scenarios) {
  * @param ctx - The AutoBeContext containing model, vendor and configuration
  * @param scenario - The test scenario information to generate code for
  * @param artifacts - The artifacts containing the reference files and schemas
- * @returns Promise resolving to IAutoBeTestWriteApplication.IProps containing
- *   the generated test code
  */
-function process(ctx, scenario, artifacts) {
+function process(ctx, scenario, artifacts, progress) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a;
+        var _a, _b;
         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 : {})),
+        const { tokenUsage } = yield ctx.conversate({
+            source: "testWrite",
             histories: (0, transformTestWriteHistories_1.transformTestWriteHistories)(scenario, artifacts),
-            controllers: [
-                createApplication({
-                    model: ctx.model,
-                    artifacts,
-                    build: (next) => {
-                        pointer.value = next;
-                    },
-                }),
-            ],
-        });
-        (0, enforceToolCall_1.enforceToolCall)(agentica);
-        yield agentica.conversate("Create e2e test functions.").finally(() => {
-            const tokenUsage = agentica.getTokenUsage();
-            ctx.usage().record(tokenUsage, ["test"]);
+            controller: createController({
+                model: ctx.model,
+                artifacts,
+                build: (next) => {
+                    pointer.value = next;
+                },
+            }),
+            enforceFunctionCall: true,
+            message: "Create e2e test functions.",
         });
         if (pointer.value === null)
             throw new Error("Failed to create test code.");
         const compiler = yield ctx.compiler();
         pointer.value.final = yield compiler.typescript.beautify(pointer.value.final);
-        return pointer.value;
+        return Object.assign(Object.assign({ type: "testWrite", created_at: new Date().toISOString(), location: `test/features/api/${pointer.value.domain}/${scenario.functionName}.ts` }, pointer.value), { tokenUsage, completed: ++progress.completed, total: progress.total, step: (_b = (_a = ctx.state().interface) === null || _a === void 0 ? void 0 : _a.step) !== null && _b !== void 0 ? _b : 0 });
     });
 }
-function createApplication(props) {
+function createController(props) {
     (0, assertSchemaModel_1.assertSchemaModel)(props.model);
     const application = collection[props.model];
     return {
@@ -167,7 +152,8 @@ const claude = {
                     },
                     domain: {
                         description: "Step 2: Functional domain classification for test organization.\n\nAI determines the appropriate domain category based on the scenario\nanalysis. This classification drives file structure, test categorization,\nand logical grouping. The domain must be a single, lowercase word that\nrepresents the primary API resource.\n\nWorkflow: Scenario analysis \u2192 Domain identification \u2192 Test organization\nstructure",
-                        type: "string"
+                        type: "string",
+                        pattern: "^[a-z][a-z0-9_]*$"
                     },
                     draft: {
                         description: "Step 3: Initial TypeScript E2E test code implementation.\n\nAI generates the first working version of the test code based on the\nstrategic plan. This draft must be compilation-error-free and follow",
@@ -193,13 +179,17 @@ const claude = {
                 $defs: {}
             },
             description: "Main entry point for AI Function Call - generates complete E2E test code.\n\nThe AI executes this function to perform the entire test generation\nworkflow: scenario analysis \u2192 draft implementation \u2192 code review \u2192 final\ncode production. This structured approach ensures high-quality,\ncompilation-error-free test code.",
-            validate: (() => { const _io0 = input => "string" === typeof input.scenario && "string" === typeof input.domain && "string" === typeof input.draft && "string" === typeof input.review && "string" === typeof input.final; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.scenario || _report(_exceptionable, {
+            validate: (() => { const _io0 = input => "string" === typeof input.scenario && ("string" === typeof input.domain && RegExp("^[a-z][a-z0-9_]*$").test(input.domain)) && "string" === typeof input.draft && "string" === typeof input.review && "string" === typeof input.final; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.scenario || _report(_exceptionable, {
                     path: _path + ".scenario",
                     expected: "string",
                     value: input.scenario
-                }), "string" === typeof input.domain || _report(_exceptionable, {
+                }), "string" === typeof input.domain && (RegExp("^[a-z][a-z0-9_]*$").test(input.domain) || _report(_exceptionable, {
                     path: _path + ".domain",
-                    expected: "string",
+                    expected: "string & SnakePattern",
+                    value: input.domain
+                })) || _report(_exceptionable, {
+                    path: _path + ".domain",
+                    expected: "(string & SnakePattern)",
                     value: input.domain
                 }), "string" === typeof input.draft || _report(_exceptionable, {
                     path: _path + ".draft",
@@ -264,7 +254,7 @@ const collection = {
                             type: "string"
                         },
                         domain: {
-                            description: "Step 2: Functional domain classification for test organization.\n\nAI determines the appropriate domain category based on the scenario\nanalysis. This classification drives file structure, test categorization,\nand logical grouping. The domain must be a single, lowercase word that\nrepresents the primary API resource.\n\nWorkflow: Scenario analysis \u2192 Domain identification \u2192 Test organization\nstructure",
+                            description: "Step 2: Functional domain classification for test organization.\n\nAI determines the appropriate domain category based on the scenario\nanalysis. This classification drives file structure, test categorization,\nand logical grouping. The domain must be a single, lowercase word that\nrepresents the primary API resource.\n\nWorkflow: Scenario analysis \u2192 Domain identification \u2192 Test organization\nstructure\n\n\n@pattern ^[a-z][a-z0-9_]*$",
                             type: "string"
                         },
                         draft: {
@@ -291,13 +281,17 @@ const collection = {
                     $defs: {}
                 },
                 description: "Main entry point for AI Function Call - generates complete E2E test code.\n\nThe AI executes this function to perform the entire test generation\nworkflow: scenario analysis \u2192 draft implementation \u2192 code review \u2192 final\ncode production. This structured approach ensures high-quality,\ncompilation-error-free test code.",
-                validate: (() => { const _io0 = input => "string" === typeof input.scenario && "string" === typeof input.domain && "string" === typeof input.draft && "string" === typeof input.review && "string" === typeof input.final; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.scenario || _report(_exceptionable, {
+                validate: (() => { const _io0 = input => "string" === typeof input.scenario && ("string" === typeof input.domain && RegExp("^[a-z][a-z0-9_]*$").test(input.domain)) && "string" === typeof input.draft && "string" === typeof input.review && "string" === typeof input.final; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.scenario || _report(_exceptionable, {
                         path: _path + ".scenario",
                         expected: "string",
                         value: input.scenario
-                    }), "string" === typeof input.domain || _report(_exceptionable, {
+                    }), "string" === typeof input.domain && (RegExp("^[a-z][a-z0-9_]*$").test(input.domain) || _report(_exceptionable, {
                         path: _path + ".domain",
-                        expected: "string",
+                        expected: "string & SnakePattern",
+                        value: input.domain
+                    })) || _report(_exceptionable, {
+                        path: _path + ".domain",
+                        expected: "(string & SnakePattern)",
                         value: input.domain
                     }), "string" === typeof input.draft || _report(_exceptionable, {
                         path: _path + ".draft",
@@ -365,6 +359,7 @@ const collection = {
                         },
                         domain: {
                             type: "string",
+                            pattern: "^[a-z][a-z0-9_]*$",
                             description: "Step 2: Functional domain classification for test organization.\n\nAI determines the appropriate domain category based on the scenario\nanalysis. This classification drives file structure, test categorization,\nand logical grouping. The domain must be a single, lowercase word that\nrepresents the primary API resource.\n\nWorkflow: Scenario analysis \u2192 Domain identification \u2192 Test organization\nstructure"
                         },
                         draft: {
@@ -391,13 +386,17 @@ const collection = {
                     additionalProperties: false
                 },
                 description: "Main entry point for AI Function Call - generates complete E2E test code.\n\nThe AI executes this function to perform the entire test generation\nworkflow: scenario analysis \u2192 draft implementation \u2192 code review \u2192 final\ncode production. This structured approach ensures high-quality,\ncompilation-error-free test code.",
-                validate: (() => { const _io0 = input => "string" === typeof input.scenario && "string" === typeof input.domain && "string" === typeof input.draft && "string" === typeof input.review && "string" === typeof input.final; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.scenario || _report(_exceptionable, {
+                validate: (() => { const _io0 = input => "string" === typeof input.scenario && ("string" === typeof input.domain && RegExp("^[a-z][a-z0-9_]*$").test(input.domain)) && "string" === typeof input.draft && "string" === typeof input.review && "string" === typeof input.final; const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.scenario || _report(_exceptionable, {
                         path: _path + ".scenario",
                         expected: "string",
                         value: input.scenario
-                    }), "string" === typeof input.domain || _report(_exceptionable, {
+                    }), "string" === typeof input.domain && (RegExp("^[a-z][a-z0-9_]*$").test(input.domain) || _report(_exceptionable, {
                         path: _path + ".domain",
-                        expected: "string",
+                        expected: "string & SnakePattern",
+                        value: input.domain
+                    })) || _report(_exceptionable, {
+                        path: _path + ".domain",
+                        expected: "(string & SnakePattern)",
                         value: input.domain
                     }), "string" === typeof input.draft || _report(_exceptionable, {
                         path: _path + ".draft",

package/lib/agent/src/orchestrate/test/orchestrateTestWrite.js.map

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

package/lib/agent/src/orchestrate/test/structures/IAutoBeTestCorrectApplication.d.ts

@@ -0,0 +1,121 @@
+export interface IAutoBeTestCorrectApplication {
+    /**
+     * Main entry point for AI Function Call - analyzes compilation errors and
+     * generates corrected E2E test code.
+     *
+     * The AI executes this function to perform the complete error correction
+     * workflow: error-free analysis → compilation error analysis → draft
+     * correction → code review → final corrected implementation. This multi-step
+     * process ensures systematic error resolution while preserving original test
+     * functionality and maintaining code quality.
+     *
+     * The corrector first analyzes the scenario without considering compilation
+     * errors to understand the intended functionality, then incorporates
+     * compilation diagnostics to identify specific issues, and finally produces
+     * corrected code through iterative refinement with comprehensive review and
+     * validation.
+     *
+     * @param props Complete specification for error correction workflow including
+     *   analysis steps, draft implementation, review process, and final code
+     *   generation
+     */
+    rewrite(props: IAutoBeTestCorrectApplication.IProps): void;
+}
+export declare namespace IAutoBeTestCorrectApplication {
+    interface IProps {
+        /**
+         * Step 1: Initial analysis and understanding without compilation error
+         * context.
+         *
+         * AI analyzes the original test scenario, business requirements, and
+         * intended functionality without being influenced by compilation errors.
+         * This clean analysis establishes a clear understanding of what the test
+         * should accomplish, the expected business workflow, and the correct API
+         * integration patterns.
+         *
+         * This step ensures that error correction doesn't lose sight of the
+         * original test purpose and helps maintain the intended business logic
+         * while addressing technical compilation issues. The AI develops a
+         * comprehensive understanding of the test requirements before diving into
+         * error-specific details.
+         *
+         * Workflow: Scenario understanding → Business logic analysis → Intended
+         * functionality mapping
+         */
+        think_without_compile_error: string;
+        /**
+         * Step 2: Compilation error analysis and root cause identification.
+         *
+         * AI re-analyzes the scenario and implementation with full awareness of
+         * compilation errors and diagnostic information. This step involves
+         * systematic examination of error messages, identification of error
+         * patterns, and understanding of how compilation issues relate to the
+         * intended functionality.
+         *
+         * The AI correlates compilation diagnostics with the original requirements
+         * to understand where the implementation diverged from correct TypeScript
+         * usage while maintaining the business logic intent. This analysis forms
+         * the foundation for targeted error correction strategies.
+         *
+         * Workflow: Error diagnostic analysis → Root cause identification →
+         * Correction strategy planning
+         */
+        think_again_with_compile_error: string;
+        /**
+         * Step 3: Draft corrected TypeScript E2E test code implementation.
+         *
+         * AI generates the first corrected version of the test code based on error
+         * analysis and correction strategies. This draft addresses all identified
+         * compilation errors while preserving the original business logic and test
+         * workflow. The code must be compilation-error-free and follow all
+         * established conventions.
+         *
+         * The implementation incorporates lessons learned from error analysis to
+         * produce properly typed, syntactically correct code that maintains the
+         * intended test functionality. All type safety requirements and framework
+         * conventions must be followed in this corrected implementation.
+         *
+         * Workflow: Error correction → TypeScript implementation → Functional
+         * preservation Critical: Must resolve all compilation errors while
+         * maintaining original test intent
+         */
+        draft: string;
+        /**
+         * Step 4: Code review and correction validation.
+         *
+         * AI performs a comprehensive review of the corrected draft implementation,
+         * validating that all compilation errors have been resolved and that the
+         * code maintains the original functionality. This review examines both
+         * technical correctness and business logic preservation.
+         *
+         * The review process includes verification of TypeScript compilation
+         * compatibility, API integration correctness, test workflow completeness,
+         * and adherence to all quality standards. Any remaining issues or potential
+         * improvements are identified for incorporation into the final
+         * implementation.
+         *
+         * Workflow: Draft validation → Compilation verification → Functionality
+         * review → Quality assessment
+         */
+        review: string;
+        /**
+         * Step 5: Final production-ready corrected test code.
+         *
+         * AI produces the final, polished version of the corrected test code
+         * incorporating all review feedback and validation results. This code
+         * represents the completed error correction, guaranteed to compile
+         * successfully while preserving all original test functionality and
+         * business logic.
+         *
+         * The final implementation resolves all compilation issues, maintains
+         * strict type safety, follows all established conventions, and delivers a
+         * production-ready test that accurately validates the intended API
+         * behaviors and user workflows.
+         *
+         * Workflow: Review integration → Final refinement → Production-ready
+         * implementation This is the ultimate deliverable that will replace the
+         * compilation-failed code.
+         */
+        final: string;
+    }
+}

package/lib/agent/src/orchestrate/test/structures/IAutoBeTestCorrectApplication.js.map

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

package/lib/agent/src/orchestrate/test/structures/IAutoBeTestFunction.d.ts

@@ -0,0 +1,8 @@
+import { AutoBeTestScenario } from "@autobe/interface";
+import { IAutoBeTestScenarioArtifacts } from "./IAutoBeTestScenarioArtifacts";
+export interface IAutoBeTestFunction {
+    artifacts: IAutoBeTestScenarioArtifacts;
+    scenario: AutoBeTestScenario;
+    location: string;
+    script: string;
+}

package/lib/agent/src/orchestrate/test/structures/IAutoBeTestFunction.js.map

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

package/lib/agent/src/orchestrate/test/structures/IAutoBeTestScenarioApplication.d.ts

@@ -0,0 +1,134 @@
+import { AutoBeOpenApi, SnakePattern } from "@autobe/interface";
+import { tags } from "typia";
+export interface IAutoBeTestScenarioApplication {
+    /**
+     * Make test scenarios for the given endpoints.
+     *
+     * @param props Properties containing the endpoints and test scenarios.
+     */
+    makeScenario(props: IAutoBeTestScenarioApplication.IProps): void;
+}
+export declare namespace IAutoBeTestScenarioApplication {
+    interface IProps {
+        /** Array of test scenario groups. */
+        scenarioGroups: IAutoBeTestScenarioApplication.IScenarioGroup[];
+    }
+    interface IScenarioGroup {
+        /**
+         * Target API endpoint to test.
+         *
+         * This must be **unique** across all scenario groups. An endpoint is
+         * identified by its `path` and `method` combination.
+         *
+         * Multiple test scenarios may exist for a single endpoint.
+         */
+        endpoint: AutoBeOpenApi.IEndpoint;
+        /**
+         * An array of test scenarios associated with the given endpoint.
+         *
+         * Each scenario represents a specific test case for the same `path` and
+         * `method`.
+         */
+        scenarios: IScenario[] & tags.MinItems<1>;
+    }
+    /**
+     * Represents a test scenario for a single API operation.
+     *
+     * This interface defines a structured, user-centric test draft that includes
+     * a descriptive function name, a detailed scenario draft, and logical
+     * dependencies on other endpoints required for context or setup.
+     */
+    interface IScenario {
+        /**
+         * A detailed natural language description of how this API endpoint should
+         * be tested. This should include both successful and failure scenarios,
+         * business rule validations, edge cases, and any sequence of steps
+         * necessary to perform the test. A subsequent agent will use this draft to
+         * generate multiple concrete test cases.
+         */
+        draft: string;
+        /**
+         * Descriptive function name derived from the user scenario.
+         *
+         * The function name serves as a concise, technical identifier that clearly
+         * represents the specific user scenario being described. It should be
+         * immediately understandable and directly correspond to the user situation
+         * without requiring additional context.
+         *
+         * ## Naming Convention
+         *
+         * MUST use snake_case naming convention.
+         *
+         * - Must start with `test_api_` prefix (mandatory requirement)
+         * - ALWAYS start with business feature, NOT action verbs
+         * - Business feature comes first, followed by scenario context
+         * - Embed action verbs within the scenario description, not at the beginning
+         *
+         * ## Content Structure
+         *
+         * Function names should follow this pattern:
+         * `test_api_[core_feature]_[specific_scenario]`
+         *
+         * Where:
+         *
+         * - `core_feature`: The main business feature or entity being tested
+         *   (customer, seller, cart, push_message, etc.)
+         * - `specific_scenario`: The specific operation or scenario context
+         *   (join_verification_not_found, login_success,
+         *   moderator_assignment_update, discountable_ticket_duplicated,
+         *   csv_export, etc.)
+         *
+         * ## Business Feature-Based Examples
+         *
+         * - `test_api_customer_join_verification_not_found` - Customer join
+         *   verification when verification code not found
+         * - `test_api_seller_login` - Seller login operation
+         * - `test_api_cart_discountable_ticket_duplicated` - Cart discountable ticket
+         *   with duplication scenario
+         * - `test_api_push_message_csv` - Push message functionality with CSV format
+         * - `test_api_product_review_update` - Product review update operation
+         *
+         * ## Clarity Guidelines
+         *
+         * - Prioritize clarity over brevity
+         * - Avoid technical jargon or implementation terms
+         * - Use terminology that reflects user perspective
+         * - Ensure the name alone conveys the user's intent
+         * - Make it understandable to non-technical stakeholders
+         * - Keep consistent with user scenario description
+         *
+         * ## Single Endpoint Alignment
+         *
+         * Function names must reflect scenarios that:
+         *
+         * - Accomplish user goals through this single endpoint only
+         * - Don't imply dependency on other API operations
+         * - Represent complete user interactions
+         */
+        functionName: string & SnakePattern;
+        /**
+         * A list of other API endpoints that this scenario logically depends on.
+         *
+         * These dependencies represent context or prerequisite conditions, such as
+         * authentication, resource creation, or data setup, that are relevant to
+         * the test. This list is not a strict execution order — if ordering is
+         * important, it must be described explicitly in the `purpose`.
+         */
+        dependencies: IDependencies[];
+    }
+    interface IDependencies {
+        /** Target API endpoint that this scenario depends on. */
+        endpoint: AutoBeOpenApi.IEndpoint;
+        /**
+         * A concise explanation of why this API call is relevant or required for
+         * the main test scenario.
+         *
+         * This should describe the contextual or setup role of the dependency, such
+         * as creating necessary data or establishing user authentication.
+         *
+         * Example: "Creates a category so that a product can be linked to it during
+         * creation."
+         */
+        purpose: string;
+    }
+}

package/lib/agent/src/orchestrate/test/structures/IAutoBeTestScenarioApplication.js.map

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

package/lib/agent/src/orchestrate/test/structures/IAutoBeTestScenarioArtifacts.d.ts

@@ -0,0 +1,7 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+export interface IAutoBeTestScenarioArtifacts {
+    document: AutoBeOpenApi.IDocument;
+    sdk: Record<string, string>;
+    dto: Record<string, string>;
+    e2e: Record<string, string>;
+}

package/lib/agent/src/orchestrate/test/structures/IAutoBeTestScenarioArtifacts.js.map

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

package/lib/agent/src/orchestrate/test/structures/IAutoBeTestWriteApplication.d.ts

@@ -0,0 +1,113 @@
+import { SnakePattern } from "@autobe/interface";
+export interface IAutoBeTestWriteApplication {
+    /**
+     * Main entry point for AI Function Call - generates complete E2E test code.
+     *
+     * The AI executes this function to perform the entire test generation
+     * workflow: scenario analysis → draft implementation → code review → final
+     * code production. This structured approach ensures high-quality,
+     * compilation-error-free test code.
+     *
+     * @param props Complete specification for test generation including scenario,
+     *   domain, and implementation steps
+     */
+    write(props: IAutoBeTestWriteApplication.IProps): void;
+}
+export declare namespace IAutoBeTestWriteApplication {
+    interface IProps {
+        /**
+         * Step 1: Strategic test planning and scenario analysis.
+         *
+         * AI analyzes the given test scenario and creates a comprehensive
+         * implementation strategy. This planning phase is crucial for generating
+         * well-structured, maintainable test code. The AI must define test
+         * methodology, data preparation, execution flow, and validation logic
+         * before proceeding to code implementation.
+         *
+         * Workflow: Input scenario → Strategic analysis → Detailed test plan
+         */
+        scenario: string;
+        /**
+         * Step 2: Functional domain classification for test organization.
+         *
+         * AI determines the appropriate domain category based on the scenario
+         * analysis. This classification drives file structure, test categorization,
+         * and logical grouping. The domain must be a single, lowercase word that
+         * represents the primary API resource.
+         *
+         * Workflow: Scenario analysis → Domain identification → Test organization
+         * structure
+         */
+        domain: string & SnakePattern;
+        /**
+         * Step 3: Initial TypeScript E2E test code implementation.
+         *
+         * AI generates the first working version of the test code based on the
+         * strategic plan. This draft must be compilation-error-free and follow
+         *
+         * @nestia/e2e framework conventions. The code should implement all planned
+         * test scenarios with proper async/await patterns, type safety, and
+         * comprehensive error handling.
+         *
+         * Workflow: Strategic plan → TypeScript implementation → Functional test
+         * code
+         *
+         * Critical: NO import statements, start directly with 'export async function'
+         */
+        draft: string;
+        /**
+         * Step 4: Code review and quality assessment.
+         *
+         * AI performs a thorough review of the draft implementation, examining:
+         *
+         * **Compilation & Syntax:**
+         *
+         * - TypeScript compilation errors and type mismatches
+         * - Syntax errors and missing semicolons/brackets
+         * - Correct function signatures and parameter types
+         *
+         * **Framework Compliance:**
+         *
+         * - @nestia/e2e framework conventions adherence
+         * - Proper API SDK function calling patterns
+         * - Correct use of typia.assert() and TestValidator functions
+         *
+         * **Business Logic & Test Coverage:**
+         *
+         * - Complete workflow implementation (authentication → data setup → main test
+         *   → validation)
+         * - Realistic business scenarios and user journeys
+         * - Edge case handling and error condition testing
+         * - Proper data dependencies and cleanup procedures
+         *
+         * **Code Quality & Security:**
+         *
+         * - Type safety violations (any, @ts-ignore, etc.)
+         * - Variable naming and code organization
+         * - Performance considerations and resource management
+         * - Security best practices in test data generation
+         *
+         * Workflow: Draft code → Systematic analysis → Specific improvement
+         * recommendations
+         *
+         * The review must identify concrete issues with line-by-line feedback and
+         * provide actionable solutions for each problem discovered.
+         */
+        review: string;
+        /**
+         * Step 5: Final production-ready test code.
+         *
+         * AI produces the final, polished version of the test code incorporating
+         * all review feedback. This code represents the completed test
+         * implementation, ready for production deployment. All identified issues
+         * must be resolved, and the code must meet the highest quality standards.
+         *
+         * Workflow: Review feedback → Code refinement → Production-ready
+         * implementation
+         *
+         * This is the ultimate deliverable that will be used in the actual test
+         * suite.
+         */
+        final: string;
+    }
+}

package/lib/agent/src/orchestrate/test/structures/IAutoBeTestWriteApplication.js.map

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