@autobe/agent 0.22.0 → 0.23.0

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

@@ -51,6 +51,7 @@ const __typia_transform__llmApplicationFinalize = __importStar(require("typia/li
 const utils_1 = require("@autobe/utils");
 const tstl_1 = require("tstl");
 const typia_1 = __importDefault(require("typia"));
+const NamingConvention_1 = require("typia/lib/utils/NamingConvention");
 const uuid_1 = require("uuid");
 const assertSchemaModel_1 = require("../../context/assertSchemaModel");
 const divideArray_1 = require("../../utils/divideArray");
@@ -58,12 +59,13 @@ const executeCachedBatch_1 = require("../../utils/executeCachedBatch");
 const transformTestScenarioHistories_1 = require("./histories/transformTestScenarioHistories");
 function orchestrateTestScenario(ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        const operations = (_b = (_a = ctx.state().interface) === null || _a === void 0 ? void 0 : _a.document.operations) !== null && _b !== void 0 ? _b : [];
-        if (operations.length === 0) {
+        var _a;
+        const document = (_a = ctx.state().interface) === null || _a === void 0 ? void 0 : _a.document;
+        if (document === undefined) {
             throw new Error("Cannot write test scenarios because these are no operations.");
         }
-        const dict = new tstl_1.HashMap(operations.map((op) => new tstl_1.Pair({
+        Object.entries(document.components.schemas);
+        const dict = new tstl_1.HashMap(document.operations.map((op) => new tstl_1.Pair({
             path: op.path,
             method: op.method,
         }, op)), utils_1.AutoBeEndpointComparator.hashCode, utils_1.AutoBeEndpointComparator.equals);
@@ -72,14 +74,17 @@ function orchestrateTestScenario(ctx) {
             "",
             " method | path ",
             "--------|------",
-            ...operations.map((op) => `\`${op.method}\` | \`${op.path}\``).join("\n"),
+            ...document.operations
+                .map((op) => `\`${op.method}\` | \`${op.path}\``)
+                .join("\n"),
         ].join("\n");
         const progress = {
-            total: operations.length,
+            total: document.operations.length,
             completed: 0,
         };
         const exclude = [];
-        let include = Array.from(operations);
+        let include = [...document.operations];
+        let trial = 0;
         do {
             const matrix = (0, divideArray_1.divideArray)({
                 array: include,
@@ -89,7 +94,7 @@ function orchestrateTestScenario(ctx) {
                 exclude.push(...(yield divideAndConquer(ctx, {
                     dict,
                     endpointNotFound,
-                    entire: operations,
+                    document,
                     include,
                     exclude: exclude.map((x) => x.endpoint),
                     progress,
@@ -102,7 +107,8 @@ function orchestrateTestScenario(ctx) {
                 }
                 return true;
             });
-        } while (include.length > 0);
+            progress.total = include.length + exclude.length;
+        } while (include.length > 0 && ++trial < ctx.retry);
         return exclude.flatMap((pg) => {
             return pg.scenarios.map((plan) => {
                 return {
@@ -124,7 +130,7 @@ const divideAndConquer = (ctx, props) => __awaiter(void 0, void 0, void 0, funct
     try {
         const { tokenUsage } = yield ctx.conversate({
             source: "testScenarios",
-            histories: (0, transformTestScenarioHistories_1.transformTestScenarioHistories)(ctx.state(), props.entire, props.include, props.exclude),
+            histories: (0, transformTestScenarioHistories_1.transformTestScenarioHistories)(ctx.state(), props.document, props.include, props.exclude),
             controller: createController({
                 model: ctx.model,
                 endpointNotFound: props.endpointNotFound,
@@ -132,6 +138,9 @@ const divideAndConquer = (ctx, props) => __awaiter(void 0, void 0, void 0, funct
                 authorizations,
                 build: (next) => {
                     var _a;
+                    next.scenarioGroups.forEach((sg) => sg.scenarios.forEach((s) => {
+                        s.functionName = NamingConvention_1.NamingConvention.snake(s.functionName);
+                    }));
                     (_a = pointer.value) !== null && _a !== void 0 ? _a : (pointer.value = []);
                     pointer.value.push(...next.scenarioGroups);
                 },
@@ -142,6 +151,7 @@ const divideAndConquer = (ctx, props) => __awaiter(void 0, void 0, void 0, funct
         });
         if (pointer.value.length === 0)
             return [];
+        props.progress.total = Math.max(props.progress.total, (props.progress.completed += pointer.value.length));
         ctx.dispatch({
             type: "testScenarios",
             id: (0, uuid_1.v7)(),
@@ -154,7 +164,7 @@ const divideAndConquer = (ctx, props) => __awaiter(void 0, void 0, void 0, funct
                 dependencies: s.dependencies,
             })))
                 .flat(),
-            completed: (props.progress.completed += pointer.value.length),
+            completed: props.progress.completed,
             total: props.progress.total,
             step: (_d = (_c = ctx.state().interface) === null || _c === void 0 ? void 0 : _c.step) !== null && _d !== void 0 ? _d : 0,
             created_at: new Date().toISOString(),
@@ -162,14 +172,13 @@ const divideAndConquer = (ctx, props) => __awaiter(void 0, void 0, void 0, funct
         return pointer.value;
     }
     catch (_e) {
-        console.log("test scenario, failed to function call", props.include);
         return [];
     }
 });
 function createController(props) {
     (0, assertSchemaModel_1.assertSchemaModel)(props.model);
     const validate = (next) => {
-        const result = (() => { const _io0 = input => Array.isArray(input.scenarioGroups) && input.scenarioGroups.every(elem => "object" === typeof elem && null !== elem && _io1(elem)); const _io1 = input => "object" === typeof input.endpoint && null !== input.endpoint && _io2(input.endpoint) && (Array.isArray(input.scenarios) && (1 <= input.scenarios.length && input.scenarios.every(elem => "object" === typeof elem && null !== elem && _io3(elem)))); const _io2 = input => "string" === typeof input.path && RegExp("^\\/[a-zA-Z0-9\\/_{}.-]*$").test(input.path) && ("get" === input.method || "post" === input.method || "put" === input.method || "delete" === input.method || "patch" === input.method); const _io3 = input => "string" === typeof input.draft && ("string" === typeof input.functionName && RegExp("^[a-z][a-z0-9_]*$").test(input.functionName)) && (Array.isArray(input.dependencies) && input.dependencies.every(elem => "object" === typeof elem && null !== elem && _io4(elem))); const _io4 = input => "object" === typeof input.endpoint && null !== input.endpoint && _io2(input.endpoint) && "string" === typeof input.purpose; const _vo0 = (input, _path, _exceptionable = true) => [(Array.isArray(input.scenarioGroups) || _report(_exceptionable, {
+        const result = (() => { const _io0 = input => Array.isArray(input.scenarioGroups) && input.scenarioGroups.every(elem => "object" === typeof elem && null !== elem && _io1(elem)); const _io1 = input => "object" === typeof input.endpoint && null !== input.endpoint && _io2(input.endpoint) && (Array.isArray(input.scenarios) && (1 <= input.scenarios.length && input.scenarios.every(elem => "object" === typeof elem && null !== elem && _io3(elem)))); const _io2 = input => "string" === typeof input.path && RegExp("^\\/[a-zA-Z0-9\\/_{}.-]*$").test(input.path) && ("get" === input.method || "post" === input.method || "put" === input.method || "delete" === input.method || "patch" === input.method); const _io3 = input => "string" === typeof input.draft && "string" === typeof input.functionName && (Array.isArray(input.dependencies) && input.dependencies.every(elem => "object" === typeof elem && null !== elem && _io4(elem))); const _io4 = input => "object" === typeof input.endpoint && null !== input.endpoint && _io2(input.endpoint) && "string" === typeof input.purpose; const _vo0 = (input, _path, _exceptionable = true) => [(Array.isArray(input.scenarioGroups) || _report(_exceptionable, {
                 path: _path + ".scenarioGroups",
                 expected: "Array<IAutoBeTestScenarioApplication.IScenarioGroup>",
                 value: input.scenarioGroups
@@ -229,13 +238,9 @@ function createController(props) {
                 path: _path + ".draft",
                 expected: "string",
                 value: input.draft
-            }), "string" === typeof input.functionName && (RegExp("^[a-z][a-z0-9_]*$").test(input.functionName) || _report(_exceptionable, {
-                path: _path + ".functionName",
-                expected: "string & SnakePattern",
-                value: input.functionName
-            })) || _report(_exceptionable, {
+            }), "string" === typeof input.functionName || _report(_exceptionable, {
                 path: _path + ".functionName",
-                expected: "(string & SnakePattern)",
+                expected: "string",
                 value: input.functionName
             }), (Array.isArray(input.dependencies) || _report(_exceptionable, {
                 path: _path + ".dependencies",
@@ -540,7 +545,7 @@ const collection = {
                                         type: "string"
                                     },
                                     functionName: {
-                                        description: "Descriptive function name derived from the user scenario.\n\nThe function name serves as a concise, technical identifier that clearly\nrepresents the specific user scenario being described. It should be\nimmediately understandable and directly correspond to the user situation\nwithout requiring additional context.\n\n## Naming Convention\n\nDO: Use snake_case naming convention.\n\n- Must start with `test_api_` prefix (mandatory requirement)\n- ALWAYS start with business feature, NOT action verbs\n- Business feature comes first, followed by scenario context\n- Embed action verbs within the scenario description, not at the beginning\n\n## Content Structure\n\nFunction names should follow this pattern:\n`test_api_[core_feature]_[specific_scenario]`\n\nWhere:\n\n- `core_feature`: The main business feature or entity being tested\n  (customer, seller, cart, push_message, etc.)\n- `specific_scenario`: The specific operation or scenario context\n  (join_verification_not_found, login_success,\n  moderator_assignment_update, discountable_ticket_duplicated,\n  csv_export, etc.)\n\n## Business Feature-Based Examples\n\n- `test_api_customer_join_verification_not_found` - Customer join\n  verification when verification code not found\n- `test_api_seller_login` - Seller login operation\n- `test_api_cart_discountable_ticket_duplicated` - Cart discountable ticket\n  with duplication scenario\n- `test_api_push_message_csv` - Push message functionality with CSV format\n- `test_api_product_review_update` - Product review update operation\n\n## Clarity Guidelines\n\n- Prioritize clarity over brevity\n- Avoid technical jargon or implementation terms\n- Use terminology that reflects user perspective\n- Ensure the name alone conveys the user's intent\n- Make it understandable to non-technical stakeholders\n- Keep consistent with user scenario description\n\n## Single Endpoint Alignment\n\nFunction names must reflect scenarios that:\n\n- Accomplish user goals through this single endpoint only\n- Don't imply dependency on other API operations\n- Represent complete user interactions\n\n\n@pattern ^[a-z][a-z0-9_]*$",
+                                        description: "Descriptive function name derived from the user scenario.\n\nThe function name serves as a concise, technical identifier that clearly\nrepresents the specific user scenario being described. It should be\nimmediately understandable and directly correspond to the user situation\nwithout requiring additional context.\n\n## Naming Convention\n\nDO: Use snake_case naming convention.\n\n- Must start with `test_api_` prefix (mandatory requirement)\n- ALWAYS start with business feature, NOT action verbs\n- Business feature comes first, followed by scenario context\n- Embed action verbs within the scenario description, not at the beginning\n\n## Content Structure\n\nFunction names should follow this pattern:\n`test_api_[core_feature]_[specific_scenario]`\n\nWhere:\n\n- `core_feature`: The main business feature or entity being tested\n  (customer, seller, cart, push_message, etc.)\n- `specific_scenario`: The specific operation or scenario context\n  (join_verification_not_found, login_success,\n  moderator_assignment_update, discountable_ticket_duplicated,\n  csv_export, etc.)\n\n## Business Feature-Based Examples\n\n- `test_api_customer_join_verification_not_found` - Customer join\n  verification when verification code not found\n- `test_api_seller_login` - Seller login operation\n- `test_api_cart_discountable_ticket_duplicated` - Cart discountable ticket\n  with duplication scenario\n- `test_api_push_message_csv` - Push message functionality with CSV format\n- `test_api_product_review_update` - Product review update operation\n\n## Clarity Guidelines\n\n- Prioritize clarity over brevity\n- Avoid technical jargon or implementation terms\n- Use terminology that reflects user perspective\n- Ensure the name alone conveys the user's intent\n- Make it understandable to non-technical stakeholders\n- Keep consistent with user scenario description\n\n## Single Endpoint Alignment\n\nFunction names must reflect scenarios that:\n\n- Accomplish user goals through this single endpoint only\n- Don't imply dependency on other API operations\n- Represent complete user interactions",
                                         type: "string"
                                     },
                                     dependencies: {
@@ -577,7 +582,7 @@ const collection = {
                         }
                     },
                     description: "Make test scenarios for the given endpoints.",
-                    validate: (() => { const _io0 = input => Array.isArray(input.scenarioGroups) && input.scenarioGroups.every(elem => "object" === typeof elem && null !== elem && _io1(elem)); const _io1 = input => "object" === typeof input.endpoint && null !== input.endpoint && _io2(input.endpoint) && (Array.isArray(input.scenarios) && (1 <= input.scenarios.length && input.scenarios.every(elem => "object" === typeof elem && null !== elem && _io3(elem)))); const _io2 = input => "string" === typeof input.path && RegExp("^\\/[a-zA-Z0-9\\/_{}.-]*$").test(input.path) && ("get" === input.method || "post" === input.method || "put" === input.method || "delete" === input.method || "patch" === input.method); const _io3 = input => "string" === typeof input.draft && ("string" === typeof input.functionName && RegExp("^[a-z][a-z0-9_]*$").test(input.functionName)) && (Array.isArray(input.dependencies) && input.dependencies.every(elem => "object" === typeof elem && null !== elem && _io4(elem))); const _io4 = input => "object" === typeof input.endpoint && null !== input.endpoint && _io2(input.endpoint) && "string" === typeof input.purpose; const _vo0 = (input, _path, _exceptionable = true) => [(Array.isArray(input.scenarioGroups) || _report(_exceptionable, {
+                    validate: (() => { const _io0 = input => Array.isArray(input.scenarioGroups) && input.scenarioGroups.every(elem => "object" === typeof elem && null !== elem && _io1(elem)); const _io1 = input => "object" === typeof input.endpoint && null !== input.endpoint && _io2(input.endpoint) && (Array.isArray(input.scenarios) && (1 <= input.scenarios.length && input.scenarios.every(elem => "object" === typeof elem && null !== elem && _io3(elem)))); const _io2 = input => "string" === typeof input.path && RegExp("^\\/[a-zA-Z0-9\\/_{}.-]*$").test(input.path) && ("get" === input.method || "post" === input.method || "put" === input.method || "delete" === input.method || "patch" === input.method); const _io3 = input => "string" === typeof input.draft && "string" === typeof input.functionName && (Array.isArray(input.dependencies) && input.dependencies.every(elem => "object" === typeof elem && null !== elem && _io4(elem))); const _io4 = input => "object" === typeof input.endpoint && null !== input.endpoint && _io2(input.endpoint) && "string" === typeof input.purpose; const _vo0 = (input, _path, _exceptionable = true) => [(Array.isArray(input.scenarioGroups) || _report(_exceptionable, {
                             path: _path + ".scenarioGroups",
                             expected: "Array<IAutoBeTestScenarioApplication.IScenarioGroup>",
                             value: input.scenarioGroups
@@ -637,13 +642,9 @@ const collection = {
                             path: _path + ".draft",
                             expected: "string",
                             value: input.draft
-                        }), "string" === typeof input.functionName && (RegExp("^[a-z][a-z0-9_]*$").test(input.functionName) || _report(_exceptionable, {
-                            path: _path + ".functionName",
-                            expected: "string & SnakePattern",
-                            value: input.functionName
-                        })) || _report(_exceptionable, {
+                        }), "string" === typeof input.functionName || _report(_exceptionable, {
                             path: _path + ".functionName",
-                            expected: "(string & SnakePattern)",
+                            expected: "string",
                             value: input.functionName
                         }), (Array.isArray(input.dependencies) || _report(_exceptionable, {
                             path: _path + ".dependencies",
@@ -804,8 +805,7 @@ const collection = {
                                     },
                                     functionName: {
                                         description: "Descriptive function name derived from the user scenario.\n\nThe function name serves as a concise, technical identifier that clearly\nrepresents the specific user scenario being described. It should be\nimmediately understandable and directly correspond to the user situation\nwithout requiring additional context.\n\n## Naming Convention\n\nDO: Use snake_case naming convention.\n\n- Must start with `test_api_` prefix (mandatory requirement)\n- ALWAYS start with business feature, NOT action verbs\n- Business feature comes first, followed by scenario context\n- Embed action verbs within the scenario description, not at the beginning\n\n## Content Structure\n\nFunction names should follow this pattern:\n`test_api_[core_feature]_[specific_scenario]`\n\nWhere:\n\n- `core_feature`: The main business feature or entity being tested\n  (customer, seller, cart, push_message, etc.)\n- `specific_scenario`: The specific operation or scenario context\n  (join_verification_not_found, login_success,\n  moderator_assignment_update, discountable_ticket_duplicated,\n  csv_export, etc.)\n\n## Business Feature-Based Examples\n\n- `test_api_customer_join_verification_not_found` - Customer join\n  verification when verification code not found\n- `test_api_seller_login` - Seller login operation\n- `test_api_cart_discountable_ticket_duplicated` - Cart discountable ticket\n  with duplication scenario\n- `test_api_push_message_csv` - Push message functionality with CSV format\n- `test_api_product_review_update` - Product review update operation\n\n## Clarity Guidelines\n\n- Prioritize clarity over brevity\n- Avoid technical jargon or implementation terms\n- Use terminology that reflects user perspective\n- Ensure the name alone conveys the user's intent\n- Make it understandable to non-technical stakeholders\n- Keep consistent with user scenario description\n\n## Single Endpoint Alignment\n\nFunction names must reflect scenarios that:\n\n- Accomplish user goals through this single endpoint only\n- Don't imply dependency on other API operations\n- Represent complete user interactions",
-                                        type: "string",
-                                        pattern: "^[a-z][a-z0-9_]*$"
+                                        type: "string"
                                     },
                                     dependencies: {
                                         description: "A list of other API endpoints that this scenario logically depends on.\n\nThese dependencies represent context or prerequisite conditions, such as\nauthentication, resource creation, or data setup, that are relevant to\nthe test. This list is not a strict execution order \u2014 if ordering is\nimportant, it must be described explicitly in the `purpose`.\n\nWARNING: Every endpoint referenced here MUST exist in the provided API\noperations. Do NOT reference endpoints that are not explicitly available,\neven if they seem logically necessary based on database schema or\nbusiness logic.",
@@ -841,7 +841,7 @@ const collection = {
                         }
                     },
                     description: "Make test scenarios for the given endpoints.",
-                    validate: (() => { const _io0 = input => Array.isArray(input.scenarioGroups) && input.scenarioGroups.every(elem => "object" === typeof elem && null !== elem && _io1(elem)); const _io1 = input => "object" === typeof input.endpoint && null !== input.endpoint && _io2(input.endpoint) && (Array.isArray(input.scenarios) && (1 <= input.scenarios.length && input.scenarios.every(elem => "object" === typeof elem && null !== elem && _io3(elem)))); const _io2 = input => "string" === typeof input.path && RegExp("^\\/[a-zA-Z0-9\\/_{}.-]*$").test(input.path) && ("get" === input.method || "post" === input.method || "put" === input.method || "delete" === input.method || "patch" === input.method); const _io3 = input => "string" === typeof input.draft && ("string" === typeof input.functionName && RegExp("^[a-z][a-z0-9_]*$").test(input.functionName)) && (Array.isArray(input.dependencies) && input.dependencies.every(elem => "object" === typeof elem && null !== elem && _io4(elem))); const _io4 = input => "object" === typeof input.endpoint && null !== input.endpoint && _io2(input.endpoint) && "string" === typeof input.purpose; const _vo0 = (input, _path, _exceptionable = true) => [(Array.isArray(input.scenarioGroups) || _report(_exceptionable, {
+                    validate: (() => { const _io0 = input => Array.isArray(input.scenarioGroups) && input.scenarioGroups.every(elem => "object" === typeof elem && null !== elem && _io1(elem)); const _io1 = input => "object" === typeof input.endpoint && null !== input.endpoint && _io2(input.endpoint) && (Array.isArray(input.scenarios) && (1 <= input.scenarios.length && input.scenarios.every(elem => "object" === typeof elem && null !== elem && _io3(elem)))); const _io2 = input => "string" === typeof input.path && RegExp("^\\/[a-zA-Z0-9\\/_{}.-]*$").test(input.path) && ("get" === input.method || "post" === input.method || "put" === input.method || "delete" === input.method || "patch" === input.method); const _io3 = input => "string" === typeof input.draft && "string" === typeof input.functionName && (Array.isArray(input.dependencies) && input.dependencies.every(elem => "object" === typeof elem && null !== elem && _io4(elem))); const _io4 = input => "object" === typeof input.endpoint && null !== input.endpoint && _io2(input.endpoint) && "string" === typeof input.purpose; const _vo0 = (input, _path, _exceptionable = true) => [(Array.isArray(input.scenarioGroups) || _report(_exceptionable, {
                             path: _path + ".scenarioGroups",
                             expected: "Array<IAutoBeTestScenarioApplication.IScenarioGroup>",
                             value: input.scenarioGroups
@@ -901,13 +901,9 @@ const collection = {
                             path: _path + ".draft",
                             expected: "string",
                             value: input.draft
-                        }), "string" === typeof input.functionName && (RegExp("^[a-z][a-z0-9_]*$").test(input.functionName) || _report(_exceptionable, {
+                        }), "string" === typeof input.functionName || _report(_exceptionable, {
                             path: _path + ".functionName",
-                            expected: "string & SnakePattern",
-                            value: input.functionName
-                        })) || _report(_exceptionable, {
-                            path: _path + ".functionName",
-                            expected: "(string & SnakePattern)",
+                            expected: "string",
                             value: input.functionName
                         }), (Array.isArray(input.dependencies) || _report(_exceptionable, {
                             path: _path + ".dependencies",

package/lib/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 → orchestrate}/test/orchestrateTestWrite.js

@@ -48,6 +48,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.orchestrateTestWrite = orchestrateTestWrite;
 const __typia_transform__validateReport = __importStar(require("typia/lib/internal/_validateReport.js"));
 const typia_1 = __importDefault(require("typia"));
+const NamingConvention_1 = require("typia/lib/utils/NamingConvention");
 const uuid_1 = require("uuid");
 const assertSchemaModel_1 = require("../../context/assertSchemaModel");
 const executeCachedBatch_1 = require("../../utils/executeCachedBatch");
@@ -82,7 +83,7 @@ function orchestrateTestWrite(ctx, scenarios) {
                     event,
                 };
             }
-            catch (error) {
+            catch (_a) {
                 return null;
             }
         })));
@@ -101,8 +102,8 @@ function process(ctx, props) {
             histories: yield (0, transformTestWriteHistories_1.transformTestWriteHistories)(ctx, scenario, artifacts),
             controller: createController({
                 model: ctx.model,
-                artifacts,
                 build: (next) => {
+                    next.domain = NamingConvention_1.NamingConvention.snake(next.domain);
                     pointer.value = next;
                 },
             }),
@@ -114,11 +115,8 @@ function process(ctx, props) {
             ++progress.completed;
             throw new Error("Failed to create test code.");
         }
-        const compiler = yield ctx.compiler();
-        if (pointer.value.revise)
-            pointer.value.revise.final = yield compiler.typescript.beautify(pointer.value.revise.final);
-        else
-            pointer.value.draft = yield compiler.typescript.beautify(pointer.value.draft);
+        pointer.value.revise.final = yield (0, completeTestCode_1.completeTestCode)(ctx, artifacts, pointer.value.revise.final);
+        pointer.value.draft = yield (0, completeTestCode_1.completeTestCode)(ctx, artifacts, pointer.value.draft);
         return {
             type: "testWrite",
             id: (0, uuid_1.v7)(),
@@ -145,9 +143,6 @@ function createController(props) {
         application,
         execute: {
             write: (next) => {
-                next.draft = (0, completeTestCode_1.completeTestCode)(props.artifacts, next.draft);
-                if (next.revise)
-                    next.revise.final = (0, completeTestCode_1.completeTestCode)(props.artifacts, next.revise.final);
                 props.build(next);
             },
         },
@@ -172,15 +167,14 @@ 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 in\nsnake_case format that represents the primary API resource.\n\nWorkflow: Scenario analysis \u2192 Domain identification \u2192 Test organization\nstructure",
-                        type: "string",
-                        pattern: "^[a-z][a-z0-9_]*$"
+                        type: "string"
                     },
                     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",
                         type: "string"
                     },
                     revise: {
-                        description: "Steps 4-5: Code review and final refinement process.\n\nContains the iterative improvement workflow that transforms the initial\ndraft into production-ready test code. This two-phase process ensures\nsystematic quality enhancement through comprehensive review followed by\ntargeted refinement based on identified issues.\n\nWorkflow: Draft \u2192 Review analysis \u2192 Final implementation",
+                        description: "Steps 4-5: Code review and final refinement process.\n\nContains the iterative improvement workflow that transforms the initial\ndraft into production-ready test code. The review phase identifies issues\nto fix or code to delete, followed by the final phase that produces\nthe polished, production-ready test implementation.\n\nWorkflow: Draft \u2192 Review analysis \u2192 Final implementation",
                         $ref: "#/$defs/IAutoBeTestWriteApplication.IReviseProps"
                     }
                 },
@@ -196,11 +190,11 @@ const claude = {
                         type: "object",
                         properties: {
                             review: {
-                                description: "Step 4: Code review and quality assessment.\n\nAI performs a thorough review of the draft implementation, examining:\n\n**Compilation & Syntax:**\n\n- TypeScript compilation errors and type mismatches\n- Syntax errors and missing semicolons/brackets\n- Correct function signatures and parameter types\n\n**Framework Compliance:**\n\n-",
+                                description: "Step 4: Code review and quality assessment.\n\n**\uD83D\uDEA8 TWO TYPES OF REVISIONS: FIX AND DELETE \uD83D\uDEA8**\n\nAI performs a thorough review of the draft implementation for:\n\n**1. FIX - Improve existing code:**\n\n**Compilation & Syntax:**\n\n- TypeScript compilation errors and type mismatches\n- Syntax errors and missing semicolons/brackets\n- Correct function signatures and parameter types\n\n**Framework Compliance:**\n\n-",
                                 type: "string"
                             },
                             final: {
-                                description: "Step 5: Final production-ready test code.\n\nAI produces the final, polished version of the test code incorporating\nall review feedback. This code represents the completed test\nimplementation, ready for production deployment. All identified issues\nmust be resolved, and the code must meet the highest quality standards.\n\nWorkflow: Review feedback \u2192 Code refinement \u2192 Production-ready\nimplementation\n\nThis is the ultimate deliverable that will be used in the actual test\nsuite.",
+                                description: "Step 5: Final production-ready test code.\n\nAI produces the final, polished version of the test code incorporating\nall review feedback. This code represents the completed test\nimplementation, ready for production deployment.\n\n**\uD83D\uDEA8 CRITICAL: APPLY ALL FIXES AND DELETIONS FROM REVIEW \uD83D\uDEA8**\n\n- FIX all correctable issues identified in review\n- DELETE all prohibited code identified in review\n- If review found type error tests, they MUST be deleted in final\n- If review found code to DELETE, final MUST be different from draft\n\nAll identified issues must be resolved, and the code must meet the\nhighest quality standards.\n\nWorkflow: Review feedback \u2192 Apply FIXES \u2192 Apply DELETIONS \u2192\nProduction-ready implementation\n\nThis is the ultimate deliverable that will be used in the actual test\nsuite.",
                                 type: "string"
                             }
                         },
@@ -212,17 +206,13 @@ const claude = {
                 }
             },
             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 && RegExp("^[a-z][a-z0-9_]*$").test(input.domain)) && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise)); const _io1 = input => "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 && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise)); const _io1 = input => "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 && (RegExp("^[a-z][a-z0-9_]*$").test(input.domain) || _report(_exceptionable, {
-                    path: _path + ".domain",
-                    expected: "string & SnakePattern",
-                    value: input.domain
-                })) || _report(_exceptionable, {
+                }), "string" === typeof input.domain || _report(_exceptionable, {
                     path: _path + ".domain",
-                    expected: "(string & SnakePattern)",
+                    expected: "string",
                     value: input.domain
                 }), "string" === typeof input.draft || _report(_exceptionable, {
                     path: _path + ".draft",
@@ -287,7 +277,7 @@ const collection = {
             {
                 name: "write",
                 parameters: {
-                    description: " Complete specification for test generation including scenario,\ndomain, and implementation steps\n\n------------------------------\n\nCurrent Type: {@link IAutoBeTestWriteApplication.IProps}\n\n### Description of {@link revise} property:\n\n> Steps 4-5: Code review and final refinement process.\n> \n> Contains the iterative improvement workflow that transforms the initial\n> draft into production-ready test code. This two-phase process ensures\n> systematic quality enhancement through comprehensive review followed by\n> targeted refinement based on identified issues.\n> \n> Workflow: Draft \u2192 Review analysis \u2192 Final implementation",
+                    description: " Complete specification for test generation including scenario,\ndomain, and implementation steps\n\n------------------------------\n\nCurrent Type: {@link IAutoBeTestWriteApplication.IProps}\n\n### Description of {@link revise} property:\n\n> Steps 4-5: Code review and final refinement process.\n> \n> Contains the iterative improvement workflow that transforms the initial\n> draft into production-ready test code. The review phase identifies issues\n> to fix or code to delete, followed by the final phase that produces\n> the polished, production-ready test implementation.\n> \n> Workflow: Draft \u2192 Review analysis \u2192 Final implementation",
                     type: "object",
                     properties: {
                         scenario: {
@@ -295,7 +285,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 in\nsnake_case format that represents the primary API resource.\n\nWorkflow: Scenario analysis \u2192 Domain identification \u2192 Test organization\nstructure\n\n\n@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 in\nsnake_case format that represents the primary API resource.\n\nWorkflow: Scenario analysis \u2192 Domain identification \u2192 Test organization\nstructure",
                             type: "string"
                         },
                         draft: {
@@ -318,11 +308,11 @@ const collection = {
                             type: "object",
                             properties: {
                                 review: {
-                                    description: "Step 4: Code review and quality assessment.\n\nAI performs a thorough review of the draft implementation, examining:\n\n**Compilation & Syntax:**\n\n- TypeScript compilation errors and type mismatches\n- Syntax errors and missing semicolons/brackets\n- Correct function signatures and parameter types\n\n**Framework Compliance:**\n\n-",
+                                    description: "Step 4: Code review and quality assessment.\n\n**\uD83D\uDEA8 TWO TYPES OF REVISIONS: FIX AND DELETE \uD83D\uDEA8**\n\nAI performs a thorough review of the draft implementation for:\n\n**1. FIX - Improve existing code:**\n\n**Compilation & Syntax:**\n\n- TypeScript compilation errors and type mismatches\n- Syntax errors and missing semicolons/brackets\n- Correct function signatures and parameter types\n\n**Framework Compliance:**\n\n-",
                                     type: "string"
                                 },
                                 final: {
-                                    description: "Step 5: Final production-ready test code.\n\nAI produces the final, polished version of the test code incorporating\nall review feedback. This code represents the completed test\nimplementation, ready for production deployment. All identified issues\nmust be resolved, and the code must meet the highest quality standards.\n\nWorkflow: Review feedback \u2192 Code refinement \u2192 Production-ready\nimplementation\n\nThis is the ultimate deliverable that will be used in the actual test\nsuite.",
+                                    description: "Step 5: Final production-ready test code.\n\nAI produces the final, polished version of the test code incorporating\nall review feedback. This code represents the completed test\nimplementation, ready for production deployment.\n\n**\uD83D\uDEA8 CRITICAL: APPLY ALL FIXES AND DELETIONS FROM REVIEW \uD83D\uDEA8**\n\n- FIX all correctable issues identified in review\n- DELETE all prohibited code identified in review\n- If review found type error tests, they MUST be deleted in final\n- If review found code to DELETE, final MUST be different from draft\n\nAll identified issues must be resolved, and the code must meet the\nhighest quality standards.\n\nWorkflow: Review feedback \u2192 Apply FIXES \u2192 Apply DELETIONS \u2192\nProduction-ready implementation\n\nThis is the ultimate deliverable that will be used in the actual test\nsuite.",
                                     type: "string"
                                 }
                             },
@@ -334,17 +324,13 @@ const collection = {
                     }
                 },
                 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 && RegExp("^[a-z][a-z0-9_]*$").test(input.domain)) && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise)); const _io1 = input => "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 && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise)); const _io1 = input => "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 && (RegExp("^[a-z][a-z0-9_]*$").test(input.domain) || _report(_exceptionable, {
-                        path: _path + ".domain",
-                        expected: "string & SnakePattern",
-                        value: input.domain
-                    })) || _report(_exceptionable, {
+                    }), "string" === typeof input.domain || _report(_exceptionable, {
                         path: _path + ".domain",
-                        expected: "(string & SnakePattern)",
+                        expected: "string",
                         value: input.domain
                     }), "string" === typeof input.draft || _report(_exceptionable, {
                         path: _path + ".draft",
@@ -420,7 +406,6 @@ 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 in\nsnake_case format that represents the primary API resource.\n\nWorkflow: Scenario analysis \u2192 Domain identification \u2192 Test organization\nstructure"
                         },
                         draft: {
@@ -432,18 +417,18 @@ const collection = {
                             properties: {
                                 review: {
                                     type: "string",
-                                    description: "Step 4: Code review and quality assessment.\n\nAI performs a thorough review of the draft implementation, examining:\n\n**Compilation & Syntax:**\n\n- TypeScript compilation errors and type mismatches\n- Syntax errors and missing semicolons/brackets\n- Correct function signatures and parameter types\n\n**Framework Compliance:**\n\n-"
+                                    description: "Step 4: Code review and quality assessment.\n\n**\uD83D\uDEA8 TWO TYPES OF REVISIONS: FIX AND DELETE \uD83D\uDEA8**\n\nAI performs a thorough review of the draft implementation for:\n\n**1. FIX - Improve existing code:**\n\n**Compilation & Syntax:**\n\n- TypeScript compilation errors and type mismatches\n- Syntax errors and missing semicolons/brackets\n- Correct function signatures and parameter types\n\n**Framework Compliance:**\n\n-"
                                 },
                                 final: {
                                     type: "string",
-                                    description: "Step 5: Final production-ready test code.\n\nAI produces the final, polished version of the test code incorporating\nall review feedback. This code represents the completed test\nimplementation, ready for production deployment. All identified issues\nmust be resolved, and the code must meet the highest quality standards.\n\nWorkflow: Review feedback \u2192 Code refinement \u2192 Production-ready\nimplementation\n\nThis is the ultimate deliverable that will be used in the actual test\nsuite."
+                                    description: "Step 5: Final production-ready test code.\n\nAI produces the final, polished version of the test code incorporating\nall review feedback. This code represents the completed test\nimplementation, ready for production deployment.\n\n**\uD83D\uDEA8 CRITICAL: APPLY ALL FIXES AND DELETIONS FROM REVIEW \uD83D\uDEA8**\n\n- FIX all correctable issues identified in review\n- DELETE all prohibited code identified in review\n- If review found type error tests, they MUST be deleted in final\n- If review found code to DELETE, final MUST be different from draft\n\nAll identified issues must be resolved, and the code must meet the\nhighest quality standards.\n\nWorkflow: Review feedback \u2192 Apply FIXES \u2192 Apply DELETIONS \u2192\nProduction-ready implementation\n\nThis is the ultimate deliverable that will be used in the actual test\nsuite."
                                 }
                             },
                             required: [
                                 "review",
                                 "final"
                             ],
-                            description: "Steps 4-5: Code review and final refinement process.\n\nContains the iterative improvement workflow that transforms the initial\ndraft into production-ready test code. This two-phase process ensures\nsystematic quality enhancement through comprehensive review followed by\ntargeted refinement based on identified issues.\n\nWorkflow: Draft \u2192 Review analysis \u2192 Final implementation\n\n------------------------------\n\nCurrent Type: {@link IAutoBeTestWriteApplication.IReviseProps}",
+                            description: "Steps 4-5: Code review and final refinement process.\n\nContains the iterative improvement workflow that transforms the initial\ndraft into production-ready test code. The review phase identifies issues\nto fix or code to delete, followed by the final phase that produces\nthe polished, production-ready test implementation.\n\nWorkflow: Draft \u2192 Review analysis \u2192 Final implementation\n\n------------------------------\n\nCurrent Type: {@link IAutoBeTestWriteApplication.IReviseProps}",
                             additionalProperties: false
                         }
                     },
@@ -457,17 +442,13 @@ 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 && RegExp("^[a-z][a-z0-9_]*$").test(input.domain)) && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise)); const _io1 = input => "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 && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io1(input.revise)); const _io1 = input => "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 && (RegExp("^[a-z][a-z0-9_]*$").test(input.domain) || _report(_exceptionable, {
+                    }), "string" === typeof input.domain || _report(_exceptionable, {
                         path: _path + ".domain",
-                        expected: "string & SnakePattern",
-                        value: input.domain
-                    })) || _report(_exceptionable, {
-                        path: _path + ".domain",
-                        expected: "(string & SnakePattern)",
+                        expected: "string",
                         value: input.domain
                     }), "string" === typeof input.draft || _report(_exceptionable, {
                         path: _path + ".draft",

package/lib/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/orchestrate/test/structures/IAutoBeTestCorrectApplication.js.map

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