@autobe/agent 0.22.0 → 0.23.0

package/src/orchestrate/test/orchestrateTestScenario.ts

@@ -9,6 +9,7 @@ import { AutoBeEndpointComparator, MapUtil, StringUtil } from "@autobe/utils";
 import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
 import { HashMap, IPointer, Pair } from "tstl";
 import typia from "typia";
+import { NamingConvention } from "typia/lib/utils/NamingConvention";
 import { v7 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
@@ -22,17 +23,19 @@ import { IAutoBeTestScenarioAuthorizationRole } from "./structures/IAutoBeTestSc
 export async function orchestrateTestScenario<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
 ): Promise<AutoBeTestScenario[]> {
-  const operations: AutoBeOpenApi.IOperation[] =
-    ctx.state().interface?.document.operations ?? [];
-  if (operations.length === 0) {
+  const document: AutoBeOpenApi.IDocument | undefined =
+    ctx.state().interface?.document;
+  if (document === undefined) {
     throw new Error(
       "Cannot write test scenarios because these are no operations.",
     );
   }
 
+  Object.entries(document.components.schemas);
+
   const dict: HashMap<AutoBeOpenApi.IEndpoint, AutoBeOpenApi.IOperation> =
     new HashMap<AutoBeOpenApi.IEndpoint, AutoBeOpenApi.IOperation>(
-      operations.map(
+      document.operations.map(
         (op) =>
           new Pair(
             {
@@ -51,15 +54,18 @@ export async function orchestrateTestScenario<Model extends ILlmSchema.Model>(
     "",
     " 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: AutoBeProgressEventBase = {
-    total: operations.length,
+    total: document.operations.length,
     completed: 0,
   };
   const exclude: IAutoBeTestScenarioApplication.IScenarioGroup[] = [];
-  let include: AutoBeOpenApi.IOperation[] = Array.from(operations);
+  let include: AutoBeOpenApi.IOperation[] = [...document.operations];
+  let trial: number = 0;
 
   do {
     const matrix: AutoBeOpenApi.IOperation[][] = divideArray({
@@ -72,7 +78,7 @@ export async function orchestrateTestScenario<Model extends ILlmSchema.Model>(
           ...(await divideAndConquer(ctx, {
             dict,
             endpointNotFound,
-            entire: operations,
+            document,
             include,
             exclude: exclude.map((x) => x.endpoint),
             progress,
@@ -92,7 +98,8 @@ export async function orchestrateTestScenario<Model extends ILlmSchema.Model>(
       }
       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) => {
@@ -111,7 +118,7 @@ const divideAndConquer = async <Model extends ILlmSchema.Model>(
   props: {
     dict: HashMap<AutoBeOpenApi.IEndpoint, AutoBeOpenApi.IOperation>;
     endpointNotFound: string;
-    entire: AutoBeOpenApi.IOperation[];
+    document: AutoBeOpenApi.IDocument;
     include: AutoBeOpenApi.IOperation[];
     exclude: AutoBeOpenApi.IEndpoint[];
     progress: AutoBeProgressEventBase;
@@ -129,7 +136,7 @@ const divideAndConquer = async <Model extends ILlmSchema.Model>(
       source: "testScenarios",
       histories: transformTestScenarioHistories(
         ctx.state(),
-        props.entire,
+        props.document,
         props.include,
         props.exclude,
       ),
@@ -139,6 +146,11 @@ const divideAndConquer = async <Model extends ILlmSchema.Model>(
         dict: props.dict,
         authorizations,
         build: (next) => {
+          next.scenarioGroups.forEach((sg) =>
+            sg.scenarios.forEach((s) => {
+              s.functionName = NamingConvention.snake(s.functionName);
+            }),
+          );
           pointer.value ??= [];
           pointer.value.push(...next.scenarioGroups);
         },
@@ -148,6 +160,11 @@ const divideAndConquer = async <Model extends ILlmSchema.Model>(
       message: `Create e2e test scenarios.`,
     });
     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: v7(),
@@ -165,14 +182,13 @@ const divideAndConquer = async <Model extends ILlmSchema.Model>(
           ),
         )
         .flat(),
-      completed: (props.progress.completed += pointer.value.length),
+      completed: props.progress.completed,
       total: props.progress.total,
       step: ctx.state().interface?.step ?? 0,
       created_at: new Date().toISOString(),
     });
     return pointer.value;
   } catch {
-    console.log("test scenario, failed to function call", props.include);
     return [];
   }
 };

package/src/orchestrate/test/orchestrateTestWrite.ts

@@ -3,11 +3,11 @@ import {
   AutoBeProgressEventBase,
   AutoBeTestScenario,
   AutoBeTestWriteEvent,
-  IAutoBeCompiler,
 } from "@autobe/interface";
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
 import { IPointer } from "tstl";
 import typia from "typia";
+import { NamingConvention } from "typia/lib/utils/NamingConvention";
 import { v7 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
@@ -50,7 +50,7 @@ export async function orchestrateTestWrite<Model extends ILlmSchema.Model>(
           artifacts,
           event,
         };
-      } catch (error) {
+      } catch {
         return null;
       }
     }),
@@ -76,8 +76,8 @@ async function process<Model extends ILlmSchema.Model>(
     histories: await transformTestWriteHistories(ctx, scenario, artifacts),
     controller: createController({
       model: ctx.model,
-      artifacts,
       build: (next) => {
+        next.domain = NamingConvention.snake(next.domain);
         pointer.value = next;
       },
     }),
@@ -90,15 +90,16 @@ async function process<Model extends ILlmSchema.Model>(
     throw new Error("Failed to create test code.");
   }
 
-  const compiler: IAutoBeCompiler = await ctx.compiler();
-  if (pointer.value.revise)
-    pointer.value.revise.final = await compiler.typescript.beautify(
-      pointer.value.revise.final,
-    );
-  else
-    pointer.value.draft = await compiler.typescript.beautify(
-      pointer.value.draft,
-    );
+  pointer.value.revise.final = await completeTestCode(
+    ctx,
+    artifacts,
+    pointer.value.revise.final,
+  );
+  pointer.value.draft = await completeTestCode(
+    ctx,
+    artifacts,
+    pointer.value.draft,
+  );
   return {
     type: "testWrite",
     id: v7(),
@@ -118,7 +119,6 @@ async function process<Model extends ILlmSchema.Model>(
 
 function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
-  artifacts: IAutoBeTestScenarioArtifacts;
   build: (next: IAutoBeTestWriteApplication.IProps) => void;
 }): IAgenticaController.IClass<Model> {
   assertSchemaModel(props.model);
@@ -132,12 +132,6 @@ function createController<Model extends ILlmSchema.Model>(props: {
     application,
     execute: {
       write: (next) => {
-        next.draft = completeTestCode(props.artifacts, next.draft);
-        if (next.revise)
-          next.revise.final = completeTestCode(
-            props.artifacts,
-            next.revise.final,
-          );
         props.build(next);
       },
     } satisfies IAutoBeTestWriteApplication,

package/src/orchestrate/test/structures/IAutoBeTestCorrectApplication.ts

@@ -1,3 +1,13 @@
+// import { tags } from "typia";
+
+// export interface ICheck {
+//   /** The title or description of the validation rule/check item */
+//   title: string;
+
+//   /** The validation state (true: passed/satisfied, false: failed/violated) */
+//   state: boolean;
+// }
+
 export interface IAutoBeTestCorrectApplication {
   /**
    * Main entry point for AI Function Call - analyzes compilation errors and
@@ -81,6 +91,161 @@ export namespace IAutoBeTestCorrectApplication {
     revise: IReviseProps;
   }
 
+  // /**
+  //  * Comprehensive compilation error analysis and correction planning
+  //  * properties.
+  //  *
+  //  * This interface structures the AI's deep thinking process during error
+  //  * correction, requiring individual analysis of each compilation error along
+  //  * with an overall strategy assessment. The AI must meticulously examine every
+  //  * error message, understand its root cause, and propose targeted solutions
+  //  * while maintaining a holistic view of the correction process.
+  //  *
+  //  * The structure enforces granular error analysis while ensuring the AI
+  //  * maintains awareness of overarching patterns and systemic issues that may
+  //  * require broader strategic changes like scenario rewrites or architectural
+  //  * adjustments.
+  //  */
+  // export interface IThinkProps {
+  //   /**
+  //    * Individual analyses for each compilation diagnostic.
+  //    *
+  //    * Contains detailed examination of every compilation error encountered,
+  //    * with specific analysis and targeted solutions. Each entry represents a
+  //    * single compilation diagnostic that must be resolved. The AI must read the
+  //    * IAutoBeTypeScriptCompileResult.IDiagnostic objects, interpret their
+  //    * content, and provide human-readable summaries along with precise fixes.
+  //    *
+  //    * This granular approach ensures no error is overlooked and each issue
+  //    * receives appropriate attention and resolution strategy.
+  //    */
+  //   analyses: IDiagnosticAnalysis[] & tags.MinItems<1>;
+
+  //   /**
+  //    * Overall assessment of compilation issues and correction strategies.
+  //    *
+  //    * Synthesizes patterns across all individual errors to identify systemic
+  //    * issues and overarching correction strategies. This includes verification
+  //    * of TEST_WRITE.md and TEST_CORRECT.md compliance, assessment of whether
+  //    * scenario rewrites are needed, identification of common error patterns,
+  //    * and documentation of broad strategic decisions.
+  //    *
+  //    * Must address: type safety compliance, async/await patterns, scenario
+  //    * adaptation requirements, and overall code quality considerations that
+  //    * span multiple errors.
+  //    */
+  //   overall: string;
+  // }
+
+  // /**
+  //  * Detailed analysis structure for individual compilation diagnostics.
+  //  *
+  //  * Represents the AI's systematic approach to understanding and resolving each
+  //  * compilation diagnostic. Each diagnostic must be thoroughly analyzed to
+  //  * understand its root cause, with a specific solution that addresses the
+  //  * exact issue while maintaining type safety and code quality.
+  //  */
+  // export interface IDiagnosticAnalysis {
+  //   /**
+  //    * AI-generated summary of the compilation diagnostic.
+  //    *
+  //    * The AI must analyze the `IAutoBeTypeScriptCompileResult.IDiagnostic`
+  //    * object and provide a clear, concise summary of the error. This should
+  //    * include the error message, file location, line/column position, and error
+  //    * code in a human-readable format. The AI interprets and restructures the
+  //    * raw diagnostic data to present it in a more understandable way.
+  //    *
+  //    * **IMPORTANT**: The AI should not copy the raw diagnostic object. Instead,
+  //    * it must read and understand the diagnostic details, then compose a clear
+  //    * string description that captures all essential information about the
+  //    * error.
+  //    */
+  //   diagnostic: string;
+
+  //   /**
+  //    * Root cause analysis of why this compilation error occurred.
+  //    *
+  //    * **🚨 CRITICAL FIRST CHECK: Is this caused by INTENTIONAL TYPE ERROR TESTING? 🚨**
+  //    * - Look for `as any` usage in the error location
+  //    * - Check if code is intentionally sending wrong types to test type validation
+  //    * - Check if code is testing missing required fields
+  //    * - **IF YES → Root cause: "Prohibited type error testing code that must be DELETED"**
+  //    *
+  //    * **⚠️ THINK BEYOND THE DIAGNOSTIC LINE - EXPAND YOUR INVESTIGATION ⚠️**
+  //    * - Do NOT focus only on the error line - it might be just a symptom
+  //    * - The real cause might be ABOVE the error location in earlier code
+  //    * - The test scenario itself might be fundamentally flawed or impossible
+  //    * - Consider if the scenario is requesting non-existent APIs or prohibited actions
+  //    * - Example: Error on line 50 might be caused by wrong type assignment on line 20
+  //    * - Example: API call fails because the scenario describes unimplemented functionality
+  //    *
+  //    * AI must examine the error message carefully and identify the specific
+  //    * reason for failure. This includes understanding whether it's a missing
+  //    * property, type mismatch, nullable/undefined issue, incorrect API usage,
+  //    * intentional type error testing, flawed scenario, or other TypeScript
+  //    * violations. The analysis should be precise and fact-based, but also
+  //    * consider the broader context and causal relationships.
+  //    *
+  //    * **MANDATORY**: The AI must thoroughly review ALL sections of
+  //    * TEST_CORRECT.md and apply relevant error patterns and analysis guidelines
+  //    * from sections 4.1-4.16 to ensure accurate diagnosis.
+  //    *
+  //    * Example: "Property 'code' is missing because the object literal lacks
+  //    * this required field from ICommunityPlatformCommunity.ICreate interface"
+  //    *
+  //    * Example: "Type error caused by intentional wrong type test using 'as any'
+  //    * - prohibited pattern that must be deleted"
+  //    *
+  //    * Example: "API endpoint doesn't exist - scenario requests unimplemented
+  //    * functionality that cannot be tested"
+  //    */
+  //   analysis: string;
+
+  //   /**
+  //    * Specific solution to resolve this compilation error.
+  //    *
+  //    * **🚨 IF ROOT CAUSE IS TYPE ERROR TESTING → Solution: "DELETE entire test block" 🚨**
+  //    * **🚨 IF PROBLEM IS UNRECOVERABLE → Solution: "DELETE the problematic section" 🚨**
+  //    * - NEVER try to "fix" intentional type error tests - DELETE them
+  //    * - NEVER violate type safety to force a fix - DELETE instead
+  //    * - Tests using `as any` to send wrong types must be DELETED
+  //    * - Tests checking type validation must be DELETED
+  //    * - Unrecoverable compilation errors should result in DELETION
+  //    *
+  //    * **THREE SOLUTION TYPES:**
+  //    * 1. **FIX**: Correct the error while maintaining functionality
+  //    * 2. **DELETE**: Remove prohibited or unrecoverable code entirely
+  //    * 3. **REWRITE**: Restructure if the scenario itself is fundamentally flawed
+  //    *
+  //    * Detailed correction strategy that addresses the exact issue identified in
+  //    * the analysis. Solutions must be actionable, type-safe, and compliant with
+  //    * all project guidelines. For nullable/undefined errors with typia tags,
+  //    * immediately apply typia.assert(value!) pattern. For missing properties,
+  //    * specify what will be added and how.
+  //    *
+  //    * **CRITICAL**: The AI must thoroughly review BOTH TEST_WRITE.md and
+  //    * TEST_CORRECT.md before proposing solutions. All prohibitions from
+  //    * TEST_WRITE.md must be strictly respected (no type bypasses, proper
+  //    * async/await usage, etc.), and correction patterns from TEST_CORRECT.md
+  //    * sections 4.1-4.16 must be properly applied.
+  //    *
+  //    * **DELETION IS A VALID SOLUTION** when:
+  //    * - Code violates absolute prohibitions
+  //    * - Fixing would require type safety violations
+  //    * - The scenario describes impossible functionality
+  //    * - Multiple fix attempts have failed
+  //    *
+  //    * Example: "Add missing 'code' property using typia.random<string>() to
+  //    * generate a valid string value that satisfies the interface requirement"
+  //    *
+  //    * Example: "DELETE this entire test - it's testing type errors with 'as any'"
+  //    *
+  //    * Example: "DELETE this section - API endpoint doesn't exist and cannot be
+  //    * tested without violating type safety"
+  //    */
+  //   solution: string;
+  // }
+
   /**
    * Revision properties for the final review and implementation phases.
    *
@@ -88,6 +253,74 @@ export namespace IAutoBeTestCorrectApplication {
    * workflow, ensuring systematic review and production-ready code delivery.
    */
   export interface IReviseProps {
+    // /**
+    //  * Dual-document compliance validation for TEST_WRITE.md and
+    //  * TEST_CORRECT.md.
+    //  *
+    //  * This property tracks whether each section from BOTH TEST_WRITE.md and
+    //  * TEST_CORRECT.md guidelines has been properly followed. Since the correct
+    //  * agent must ensure compliance with both documents, keys should include
+    //  * sections from both prompt files.
+    //  *
+    //  * Each ICheck item should have:
+    //  *
+    //  * - Title: Prefixed with source document for clarity ("TEST_WRITE: " or
+    //  *   "TEST_CORRECT: ")
+    //  * - State: Compliance status (true if followed, false if violated)
+    //  *
+    //  * Note: Section identifiers may evolve as documentation updates, so
+    //  * implementations should be flexible in handling different key formats.
+    //  *
+    //  * Example:
+    //  *
+    //  * ```typescript
+    //  * rules: [
+    //  *   { title: "TEST_WRITE: 1. Role and Responsibility", state: true },
+    //  *   { title: "TEST_WRITE: 3.1. Import Management", state: true },
+    //  *   {
+    //  *     title: "TEST_CORRECT: 4.1. Missing Properties Pattern",
+    //  *     state: true,
+    //  *   },
+    //  *   {
+    //  *     title: "TEST_CORRECT: 4.2. Type Mismatch Pattern",
+    //  *     state: false,
+    //  *   },
+    //  *   // ... other sections from both documents
+    //  * ];
+    //  * ```
+    //  */
+    // rules: ICheck[] & tags.MinItems<1>;
+
+    // /**
+    //  * Combined quality checklist validation from both prompt documents.
+    //  *
+    //  * This property captures the compliance status for checklist items from
+    //  * BOTH TEST_WRITE.md (Section 5: Final Checklist) and TEST_CORRECT.md
+    //  * (Section 5: Final Review Checklist). The correct agent must validate
+    //  * against both checklists to ensure comprehensive quality control.
+    //  *
+    //  * Each ICheck item should have:
+    //  *
+    //  * - Title: Checklist item as described in the documents
+    //  * - State: Whether the criterion has been satisfied
+    //  *
+    //  * Note: Checklist items may be updated over time, so implementations should
+    //  * adapt to documentation changes while maintaining the validation purpose.
+    //  *
+    //  * Example:
+    //  *
+    //  * ```typescript
+    //  * checkList: [
+    //  *   { title: "No compilation errors", state: true },
+    //  *   { title: "Proper async/await usage", state: true },
+    //  *   { title: "All typia tags preserved", state: true },
+    //  *   { title: "No type bypasses or workarounds", state: false },
+    //  *   // ... other checklist items from both documents
+    //  * ];
+    //  * ```
+    //  */
+    // checkList: ICheck[] & tags.MinItems<1>;
+
     /**
      * Step 3: Code review and correction validation.
      *

package/src/orchestrate/test/structures/IAutoBeTestCorrectInvalidRequestApplication.ts

@@ -0,0 +1,146 @@
+export interface IAutoBeTestCorrectInvalidRequestApplication {
+  /**
+   * Rewrite function to remove code containing invalid type API requests.
+   *
+   * This function is called when the agent detects code that attempts to send
+   * API requests with deliberately wrong types, causing TypeScript compilation
+   * errors. The agent will remove the problematic code sections while
+   * preserving valid test code.
+   *
+   * Common patterns that trigger this function:
+   *
+   * - TestValidator.error calls testing type violations
+   * - Missing required fields with type assertions
+   * - Wrong type assignments with satisfies operator
+   * - Nested type violations in complex objects
+   * - Partial type testing with invalid structures
+   *
+   * The rationale for deletion:
+   *
+   * - Type validation is the server's responsibility, not E2E tests
+   * - TypeScript compiler should enforce type safety at compile time
+   * - Invalid type testing breaks the entire test suite compilation
+   * - E2E tests should focus on business logic, not type system violations
+   *
+   * @param props - The analysis and correction properties
+   * @param props.think - Analysis of what specific invalid request pattern is
+   *   causing the error
+   * @param props.draft - Initial corrected code with problematic sections
+   *   completely removed
+   * @param props.revise - Review process and final cleaned code
+   */
+  rewrite(props: IAutoBeTestCorrectInvalidRequestApplication.IProps): void;
+
+  /**
+   * Reject function when no invalid type API requests are detected.
+   *
+   * This function is called when the compilation error is not related to
+   * invalid API request types, indicating the agent should not intervene.
+   *
+   * Common scenarios for rejection:
+   *
+   * - Syntax errors unrelated to type violations
+   * - Legitimate type mismatches that need fixing (not deletion)
+   * - Framework-specific compilation issues
+   * - Configuration or environment problems
+   *
+   * When called, this indicates that another specialized agent should handle
+   * the compilation error, as it's outside this agent's domain.
+   */
+  reject(): void;
+}
+
+export namespace IAutoBeTestCorrectInvalidRequestApplication {
+  /**
+   * Properties for the rewrite function containing the analysis and correction
+   * workflow.
+   *
+   * This follows a three-phase approach: think → draft → revise, ensuring
+   * systematic removal of invalid type testing code while maintaining the
+   * integrity of valid E2E tests.
+   */
+  export interface IProps {
+    /**
+     * Initial analysis phase.
+     *
+     * Contains the agent's analysis of what specific invalid request pattern
+     * was found in the code and how it's causing the compilation error. This
+     * should identify:
+     *
+     * - The exact pattern (as any, satisfies, TestValidator.error, etc.)
+     * - Line numbers and locations of violations
+     * - The TypeScript error codes being triggered
+     * - Why this constitutes invalid type testing
+     *
+     * Example: "Detected TestValidator.error() call at line 45 with 'as any'
+     * casting on request body containing deliberately wrong types (number for
+     * email field). This is causing TS2345 compilation error."
+     */
+    think: string;
+
+    /**
+     * Draft correction phase.
+     *
+     * The initial corrected code with the problematic API request sections
+     * completely removed while preserving all valid test code.
+     *
+     * Rules for drafting:
+     *
+     * - Remove entire test functions containing type violations
+     * - Do not comment out code - delete it completely
+     * - Preserve test suite structure and valid tests
+     * - Maintain proper indentation and formatting
+     * - Keep imports that are still needed by remaining code
+     */
+    draft: string;
+
+    /**
+     * Review and finalization phase.
+     *
+     * Contains the review of changes made and the final cleaned code that
+     * should compile without the invalid API request errors. This ensures the
+     * correction is complete and accurate.
+     */
+    revise: IReviseProps;
+  }
+
+  /**
+   * Properties for the revision phase of the correction process.
+   *
+   * This phase ensures that the removal was complete and the remaining code is
+   * valid and compilable.
+   */
+  export interface IReviseProps {
+    /**
+     * Review of the changes made.
+     *
+     * Brief explanation of what invalid API request code was removed and
+     * verification that valid test code was preserved. Should confirm:
+     *
+     * - Which patterns were found and removed
+     * - Line ranges that were deleted
+     * - Verification that valid tests remain intact
+     * - Confirmation that no partial fixes were applied
+     *
+     * Example: "Removed lines 43-52 containing TestValidator.error with invalid
+     * type casting. Verified remaining tests are valid and unaffected."
+     */
+    review: string;
+
+    /**
+     * Final corrected code.
+     *
+     * The complete, cleaned test code with all invalid API request sections
+     * removed, ready for compilation.
+     *
+     * This code must:
+     *
+     * - Compile without TypeScript errors
+     * - Contain only valid business logic tests
+     * - Have no `as any` or similar type violations
+     * - Maintain the original file structure
+     * - Be production-ready E2E test code
+     */
+    final: string;
+  }
+}

package/src/orchestrate/test/structures/IAutoBeTestScenarioApplication.ts

@@ -1,4 +1,4 @@
-import { AutoBeOpenApi, SnakePattern } from "@autobe/interface";
+import { AutoBeOpenApi } from "@autobe/interface";
 import { tags } from "typia";
 
 export interface IAutoBeTestScenarioApplication {
@@ -128,7 +128,7 @@ export namespace IAutoBeTestScenarioApplication {
      * - Don't imply dependency on other API operations
      * - Represent complete user interactions
      */
-    functionName: string & SnakePattern;
+    functionName: string;
 
     /**
      * A list of other API endpoints that this scenario logically depends on.