@autobe/agent 0.20.0 → 0.22.0

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

@@ -4,16 +4,14 @@ export interface IAutoBeTestCorrectApplication {
      * 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.
+     * workflow: 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.
+     * The corrector analyzes compilation diagnostics to identify specific issues,
+     * develops correction strategies, and 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
@@ -24,45 +22,29 @@ export interface IAutoBeTestCorrectApplication {
 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
-         * accomplishes, 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.
+         * Step 1: Deep compilation error analysis and correction strategy.
+         *
+         * AI performs comprehensive analysis of compilation errors to develop
+         * targeted correction strategies. This step involves deep examination of
+         * error messages, identification of error patterns, understanding root
+         * causes, and planning systematic corrections.
          *
-         * 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 examines each compilation diagnostic to understand where the
+         * implementation diverged from correct TypeScript usage, identifies the
+         * business logic intent behind the failed code, and formulates strategies
+         * to fix errors while preserving the original test purpose. This analysis
+         * correlates error patterns with code structure to ensure corrections
+         * address root causes rather than symptoms.
          *
-         * 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.
+         * This deep analysis forms the foundation for all subsequent correction
+         * efforts, ensuring a methodical approach to resolving compilation issues.
          *
          * Workflow: Error diagnostic analysis → Root cause identification →
-         * Correction strategy planning
+         * Correction strategy planning → Business logic preservation strategy
          */
-        think_again_with_compile_error: string;
+        think: string;
         /**
-         * Step 3: Draft corrected TypeScript E2E test code implementation.
+         * Step 2: 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
@@ -82,7 +64,28 @@ export declare namespace IAutoBeTestCorrectApplication {
          */
         draft: string;
         /**
-         * Step 4: Code review and correction validation.
+         * Step 3-4: Review and finalization process.
+         *
+         * Encapsulates the review and final implementation phases into a single
+         * revision process. This structured approach ensures systematic validation
+         * and refinement of the corrected code through comprehensive review
+         * followed by production-ready implementation.
+         *
+         * The revision process maintains clear separation between review feedback
+         * and final deliverable while ensuring all corrections are properly
+         * validated and integrated.
+         */
+        revise: IReviseProps;
+    }
+    /**
+     * Revision properties for the final review and implementation phases.
+     *
+     * This interface encapsulates the final two steps of the error correction
+     * workflow, ensuring systematic review and production-ready code delivery.
+     */
+    interface IReviseProps {
+        /**
+         * Step 3: 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
@@ -100,7 +103,7 @@ export declare namespace IAutoBeTestCorrectApplication {
          */
         review: string;
         /**
-         * Step 5: Final production-ready corrected test code.
+         * Step 4: 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
@@ -114,7 +117,7 @@ export declare namespace IAutoBeTestCorrectApplication {
          * behaviors and user workflows.
          *
          * Workflow: Review integration → Final refinement → Production-ready
-         * implementation This is the ultimate deliverable that will replace the
+         * implementation. This is the ultimate deliverable that will replace the
          * compilation-failed code.
          */
         final: string;

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

@@ -0,0 +1,6 @@
+import { IAutoBeTypeScriptCompileResult } from "@autobe/interface";
+import { IAutoBeTestFunction } from "./IAutoBeTestFunction";
+export interface IAutoBeTestFunctionFailure {
+    function: IAutoBeTestFunction;
+    failure: IAutoBeTypeScriptCompileResult.IFailure;
+}

package/lib/agent/src/orchestrate/test/structures/IAutoBeTestFunctionFailure.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IAutoBeTestFunctionFailure.js.map

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

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

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

@@ -28,6 +28,18 @@ export declare namespace IAutoBeTestScenarioApplication {
          *
          * Each scenario represents a specific test case for the same `path` and
          * `method`.
+         *
+         * IMPORTANT: Each scenario must be actually implementable. A scenario's
+         * implementability is determined by the existence of ALL APIs (endpoints)
+         * required to test it. This includes not only the primary endpoint being
+         * tested, but also ALL dependency endpoints needed for setup,
+         * authentication, and data preparation. If even one required dependency API
+         * is missing from the available operations, the scenario cannot be
+         * implemented and should not be generated.
+         *
+         * Example: A "test banned user login" scenario requires both a login API
+         * AND a ban user API. If the ban API doesn't exist, this scenario is not
+         * implementable regardless of database schema fields.
          */
         scenarios: IScenario[] & tags.MinItems<1>;
     }
@@ -37,6 +49,11 @@ export declare namespace IAutoBeTestScenarioApplication {
      * 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.
+     *
+     * CRITICAL: All referenced endpoints MUST exist in the provided API
+     * operations. Do NOT create scenarios for non-existent APIs, even if database
+     * schema fields suggest their existence. Test scenarios must be implementable
+     * with available APIs only.
      */
     interface IScenario {
         /**
@@ -113,11 +130,21 @@ export declare namespace IAutoBeTestScenarioApplication {
          * 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`.
+         *
+         * WARNING: Every endpoint referenced here MUST exist in the provided API
+         * operations. Do NOT reference endpoints that are not explicitly available,
+         * even if they seem logically necessary based on database schema or
+         * business logic.
          */
         dependencies: IDependencies[];
     }
     interface IDependencies {
-        /** Target API endpoint that this scenario depends on. */
+        /**
+         * Target API endpoint that this scenario depends on.
+         *
+         * This endpoint MUST exist in the available API operations list.
+         * Non-existent endpoints will cause test implementation failures.
+         */
         endpoint: AutoBeOpenApi.IEndpoint;
         /**
          * A concise explanation of why this API call is relevant or required for

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

@@ -4,4 +4,5 @@ export interface IAutoBeTestScenarioArtifacts {
     sdk: Record<string, string>;
     dto: Record<string, string>;
     e2e: Record<string, string>;
+    template: string;
 }

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

@@ -55,6 +55,19 @@ export declare namespace IAutoBeTestWriteApplication {
          * Critical: NO import statements, start directly with 'export async function'
          */
         draft: string;
+        /**
+         * Steps 4-5: Code review and final refinement process.
+         *
+         * Contains the iterative improvement workflow that transforms the initial
+         * draft into production-ready test code. This two-phase process ensures
+         * systematic quality enhancement through comprehensive review followed by
+         * targeted refinement based on identified issues.
+         *
+         * Workflow: Draft → Review analysis → Final implementation
+         */
+        revise: IReviseProps;
+    }
+    interface IReviseProps {
         /**
          * Step 4: Code review and quality assessment.
          *

package/lib/agent/src/orchestrate/test/utils/getReferenceIds.d.ts

@@ -0,0 +1,5 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+export declare const getReferenceIds: (props: {
+    document: AutoBeOpenApi.IDocument;
+    operation: AutoBeOpenApi.IOperation;
+}) => string[];

package/lib/agent/src/orchestrate/test/utils/getReferenceIds.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReferenceIds = void 0;
+const openapi_1 = require("@samchon/openapi");
+const getReferenceIds = (props) => {
+    const result = new Set();
+    const emplace = (key) => {
+        if (key.endsWith("_id"))
+            result.add(key);
+    };
+    props.operation.parameters.forEach((p) => emplace(p.name));
+    if (props.operation.requestBody) {
+        openapi_1.OpenApiTypeChecker.visit({
+            components: props.document.components,
+            schema: { $ref: props.operation.requestBody.typeName },
+            closure: (schema) => {
+                var _a;
+                if (openapi_1.OpenApiTypeChecker.isObject(schema) === false)
+                    return;
+                for (const key of Object.keys((_a = schema.properties) !== null && _a !== void 0 ? _a : {}))
+                    emplace(key);
+            },
+        });
+    }
+    return Array.from(result);
+};
+exports.getReferenceIds = getReferenceIds;
+//# sourceMappingURL=getReferenceIds.js.map

package/lib/agent/src/orchestrate/test/utils/getReferenceIds.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getReferenceIds.js","sourceRoot":"","sources":["../../../../../../src/orchestrate/test/utils/getReferenceIds.ts"],"names":[],"mappings":";;;AACA,8CAAsD;AAE/C,MAAM,eAAe,GAAG,CAAC,KAG/B,EAAY,EAAE;IACb,MAAM,MAAM,GAAgB,IAAI,GAAG,EAAE,CAAC;IACtC,MAAM,OAAO,GAAG,CAAC,GAAW,EAAE,EAAE;QAC9B,IAAI,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC;YAAE,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC3C,CAAC,CAAC;IAEF,KAAK,CAAC,SAAS,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;IAC3D,IAAI,KAAK,CAAC,SAAS,CAAC,WAAW,EAAE,CAAC;QAChC,4BAAkB,CAAC,KAAK,CAAC;YACvB,UAAU,EAAE,KAAK,CAAC,QAAQ,CAAC,UAAU;YACrC,MAAM,EAAE,EAAE,IAAI,EAAE,KAAK,CAAC,SAAS,CAAC,WAAW,CAAC,QAAQ,EAAE;YACtD,OAAO,EAAE,CAAC,MAAM,EAAE,EAAE;;gBAClB,IAAI,4BAAkB,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,KAAK;oBAAE,OAAO;gBAC1D,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,MAAA,MAAM,CAAC,UAAU,mCAAI,EAAE,CAAC;oBAAE,OAAO,CAAC,GAAG,CAAC,CAAC;YACvE,CAAC;SACF,CAAC,CAAC;IACL,CAAC;IACD,OAAO,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;AAC5B,CAAC,CAAC;AArBW,QAAA,eAAe,mBAqB1B"}

package/lib/agent/src/structures/IAutoBeConfig.d.ts

@@ -16,6 +16,8 @@
  * @author Samchon
  */
 export interface IAutoBeConfig {
+    /** @default 4 */
+    retry?: number;
     /**
      * Language and cultural locale preference for AI agent communication.
      *

package/lib/constants/AutoBeConfigConstant.d.ts

@@ -0,0 +1,3 @@
+export declare const enum AutoBeConfigConstant {
+    DEFAULT_RETRY = 4
+}