@autobe/agent 0.30.0-dev.20260315 → 0.30.1

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

@@ -1,113 +1,113 @@
-export interface IAutoBeTestAuthorizationWriteApplication {
-  /**
-   * Main entry point for AI Function Call - generates authorization utility
-   * functions.
-   *
-   * The AI executes this function to generate authorization functions that
-   * handle authentication flows (login, join, refresh, etc.) for different
-   * actor types. This structured approach ensures consistent authentication
-   * handling across the test suite.
-   *
-   * @param props Complete specification for authorization function generation
-   */
-  write(props: IAutoBeTestAuthorizationWriteApplication.IProps): void;
-}
-
-export namespace IAutoBeTestAuthorizationWriteApplication {
-  export interface IProps {
-    /**
-     * Step 1: Strategic authorization analysis.
-     *
-     * AI analyzes the operation to understand authorization requirements,
-     * including the type of authentication flow, actor permissions, and
-     * required SDK functions. This analysis forms the foundation for generating
-     * appropriate authorization utilities.
-     *
-     * Workflow: Operation analysis → Authorization strategy → Implementation
-     * plan
-     */
-    think: string;
-
-    /**
-     * Step 2: Actor identification.
-     *
-     * AI determines the actor (user type) for this authorization function. This
-     * should be extracted from the context, such as the API path or operation
-     * details.
-     *
-     * Examples: "user", "admin", "moderator", "seller", "customer"
-     */
-    actor: string;
-
-    /**
-     * Step 4: Initial authorization function implementation.
-     *
-     * AI generates the authorization utility function that properly handles the
-     * authentication flow. The implementation must use correct SDK functions,
-     * return required authentication data, and include comprehensive error
-     * handling with fallback logic where needed.
-     *
-     * Critical: NO import statements, start directly with 'export const'
-     */
-    draft: string;
-
-    /**
-     * Steps 5-6: Code review and final refinement process.
-     *
-     * Contains the iterative improvement workflow that transforms the initial
-     * draft into production-ready authorization code. The review phase
-     * identifies issues to fix, followed by the final phase that produces the
-     * polished implementation ready for use in test scenarios.
-     *
-     * Workflow: Draft → Review analysis → Final implementation
-     */
-    revise: IReviseProps;
-  }
-
-  export interface IReviseProps {
-    /**
-     * Step 5: Code review and quality assessment.
-     *
-     * AI performs a thorough review of the draft implementation, checking for:
-     *
-     * **Technical Correctness:**
-     *
-     * - Proper SDK function usage and parameter types
-     * - Appropriate return types and data structures
-     * - TypeScript compilation compatibility
-     *
-     * **Authorization Logic:**
-     *
-     * - Proper handling of authentication flows
-     * - Correct token/session management
-     * - Appropriate error handling and fallback strategies
-     * - Security best practices
-     *
-     * **Code Quality:**
-     *
-     * - Clear variable naming and code organization
-     * - Comprehensive error messages
-     * - Proper async/await usage
-     * - Type safety without any/unknown usage
-     *
-     * The review must provide specific, actionable feedback for improvements.
-     */
-    review: string;
-
-    /**
-     * Step 6: Final production-ready authorization function.
-     *
-     * AI produces the final version incorporating all review feedback. This
-     * represents the completed authorization utility ready for use in test
-     * scenarios. When the draft is already perfect with no issues found during
-     * review, this value can be null.
-     *
-     * All identified issues must be resolved, and the code must meet production
-     * quality standards for test utilities.
-     *
-     * Workflow: Review feedback → Apply improvements → Production-ready code
-     * (or null if no changes needed)
-     */
-    final: string | null;
-  }
-}
+export interface IAutoBeTestAuthorizationWriteApplication {
+  /**
+   * Main entry point for AI Function Call - generates authorization utility
+   * functions.
+   *
+   * The AI executes this function to generate authorization functions that
+   * handle authentication flows (login, join, refresh, etc.) for different
+   * actor types. This structured approach ensures consistent authentication
+   * handling across the test suite.
+   *
+   * @param props Complete specification for authorization function generation
+   */
+  write(props: IAutoBeTestAuthorizationWriteApplication.IProps): void;
+}
+
+export namespace IAutoBeTestAuthorizationWriteApplication {
+  export interface IProps {
+    /**
+     * Step 1: Strategic authorization analysis.
+     *
+     * AI analyzes the operation to understand authorization requirements,
+     * including the type of authentication flow, actor permissions, and
+     * required SDK functions. This analysis forms the foundation for generating
+     * appropriate authorization utilities.
+     *
+     * Workflow: Operation analysis → Authorization strategy → Implementation
+     * plan
+     */
+    think: string;
+
+    /**
+     * Step 2: Actor identification.
+     *
+     * AI determines the actor (user type) for this authorization function. This
+     * should be extracted from the context, such as the API path or operation
+     * details.
+     *
+     * Examples: "user", "admin", "moderator", "seller", "customer"
+     */
+    actor: string;
+
+    /**
+     * Step 4: Initial authorization function implementation.
+     *
+     * AI generates the authorization utility function that properly handles the
+     * authentication flow. The implementation must use correct SDK functions,
+     * return required authentication data, and include comprehensive error
+     * handling with fallback logic where needed.
+     *
+     * Critical: NO import statements, start directly with 'export const'
+     */
+    draft: string;
+
+    /**
+     * Steps 5-6: Code review and final refinement process.
+     *
+     * Contains the iterative improvement workflow that transforms the initial
+     * draft into production-ready authorization code. The review phase
+     * identifies issues to fix, followed by the final phase that produces the
+     * polished implementation ready for use in test scenarios.
+     *
+     * Workflow: Draft → Review analysis → Final implementation
+     */
+    revise: IReviseProps;
+  }
+
+  export interface IReviseProps {
+    /**
+     * Step 5: Code review and quality assessment.
+     *
+     * AI performs a thorough review of the draft implementation, checking for:
+     *
+     * **Technical Correctness:**
+     *
+     * - Proper SDK function usage and parameter types
+     * - Appropriate return types and data structures
+     * - TypeScript compilation compatibility
+     *
+     * **Authorization Logic:**
+     *
+     * - Proper handling of authentication flows
+     * - Correct token/session management
+     * - Appropriate error handling and fallback strategies
+     * - Security best practices
+     *
+     * **Code Quality:**
+     *
+     * - Clear variable naming and code organization
+     * - Comprehensive error messages
+     * - Proper async/await usage
+     * - Type safety without any/unknown usage
+     *
+     * The review must provide specific, actionable feedback for improvements.
+     */
+    review: string;
+
+    /**
+     * Step 6: Final production-ready authorization function.
+     *
+     * AI produces the final version incorporating all review feedback. This
+     * represents the completed authorization utility ready for use in test
+     * scenarios. When the draft is already perfect with no issues found during
+     * review, this value can be null.
+     *
+     * All identified issues must be resolved, and the code must meet production
+     * quality standards for test utilities.
+     *
+     * Workflow: Review feedback → Apply improvements → Production-ready code
+     * (or null if no changes needed)
+     */
+    final: string | null;
+  }
+}

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

@@ -1,10 +1,10 @@
-import { AutoBeOpenApi, AutoBeTestAuthorizeFunction } from "@autobe/interface";
-
-import { IAutoBeTestArtifacts } from "./IAutoBeTestArtifacts";
-
-export interface IAutoBeTestAuthorizeProcedure {
-  type: "authorize";
-  operation: AutoBeOpenApi.IOperation;
-  artifacts: IAutoBeTestArtifacts;
-  function: AutoBeTestAuthorizeFunction;
-}
+import { AutoBeOpenApi, AutoBeTestAuthorizeFunction } from "@autobe/interface";
+
+import { IAutoBeTestArtifacts } from "./IAutoBeTestArtifacts";
+
+export interface IAutoBeTestAuthorizeProcedure {
+  type: "authorize";
+  operation: AutoBeOpenApi.IOperation;
+  artifacts: IAutoBeTestArtifacts;
+  function: AutoBeTestAuthorizeFunction;
+}

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

@@ -1,134 +1,134 @@
-export interface IAutoBeTestCorrectOverallApplication {
-  /**
-   * Main entry point for AI Function Call - analyzes compilation errors and
-   * generates corrected E2E test code.
-   *
-   * The AI executes this function to perform the complete error correction
-   * workflow: 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 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
-   *   generation
-   */
-  rewrite(props: IAutoBeTestCorrectOverallApplication.IProps): void;
-}
-
-export namespace IAutoBeTestCorrectOverallApplication {
-  export interface IProps {
-    /**
-     * 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.
-     *
-     * 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.
-     *
-     * 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 → Business logic preservation strategy
-     */
-    think: string;
-
-    /**
-     * 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
-     * compilation errors while preserving the original business logic and test
-     * workflow. The code is compilation-error-free and follows all established
-     * conventions.
-     *
-     * The implementation incorporates lessons learned from error analysis to
-     * produce properly typed, syntactically correct code that maintains the
-     * intended test functionality. All type safety requirements and framework
-     * conventions are followed in this corrected implementation.
-     *
-     * Workflow: Error correction → TypeScript implementation → Functional
-     * preservation
-     *
-     * DO: Resolve all compilation errors while maintaining original test intent
-     */
-    draft: string;
-
-    /**
-     * 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.
-   */
-  export 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
-     * code maintains the original functionality. This review examines both
-     * technical correctness and business logic preservation.
-     *
-     * The review process includes verification of TypeScript compilation
-     * compatibility, API integration correctness, test workflow completeness,
-     * and adherence to all quality standards. Any remaining issues or potential
-     * improvements are identified for incorporation into the final
-     * implementation.
-     *
-     * Workflow: Draft validation → Compilation verification → Functionality
-     * review → Quality assessment
-     */
-    review: string;
-
-    /**
-     * Step 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
-     * represents the completed error correction, guaranteed to compile
-     * successfully while preserving all original test functionality and
-     * business logic. When the draft correction already perfectly resolves all
-     * issues with no problems found during review, this value can be null,
-     * indicating no further refinement was necessary.
-     *
-     * The final implementation resolves all compilation issues, maintains
-     * strict type safety, follows all established conventions, and delivers a
-     * production-ready test that accurately validates the intended API
-     * behaviors and user workflows. A null value signifies the draft correction
-     * was already optimal and requires no modifications.
-     *
-     * Workflow: Review integration → Final refinement → Production-ready
-     * implementation (or null if draft needs no changes). This is the ultimate
-     * deliverable that will replace the compilation-failed code when provided,
-     * otherwise the draft correction is used as-is.
-     */
-    final: string | null;
-  }
-}
+export interface IAutoBeTestCorrectOverallApplication {
+  /**
+   * Main entry point for AI Function Call - analyzes compilation errors and
+   * generates corrected E2E test code.
+   *
+   * The AI executes this function to perform the complete error correction
+   * workflow: 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 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
+   *   generation
+   */
+  rewrite(props: IAutoBeTestCorrectOverallApplication.IProps): void;
+}
+
+export namespace IAutoBeTestCorrectOverallApplication {
+  export interface IProps {
+    /**
+     * 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.
+     *
+     * 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.
+     *
+     * 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 → Business logic preservation strategy
+     */
+    think: string;
+
+    /**
+     * 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
+     * compilation errors while preserving the original business logic and test
+     * workflow. The code is compilation-error-free and follows all established
+     * conventions.
+     *
+     * The implementation incorporates lessons learned from error analysis to
+     * produce properly typed, syntactically correct code that maintains the
+     * intended test functionality. All type safety requirements and framework
+     * conventions are followed in this corrected implementation.
+     *
+     * Workflow: Error correction → TypeScript implementation → Functional
+     * preservation
+     *
+     * DO: Resolve all compilation errors while maintaining original test intent
+     */
+    draft: string;
+
+    /**
+     * 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.
+   */
+  export 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
+     * code maintains the original functionality. This review examines both
+     * technical correctness and business logic preservation.
+     *
+     * The review process includes verification of TypeScript compilation
+     * compatibility, API integration correctness, test workflow completeness,
+     * and adherence to all quality standards. Any remaining issues or potential
+     * improvements are identified for incorporation into the final
+     * implementation.
+     *
+     * Workflow: Draft validation → Compilation verification → Functionality
+     * review → Quality assessment
+     */
+    review: string;
+
+    /**
+     * Step 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
+     * represents the completed error correction, guaranteed to compile
+     * successfully while preserving all original test functionality and
+     * business logic. When the draft correction already perfectly resolves all
+     * issues with no problems found during review, this value can be null,
+     * indicating no further refinement was necessary.
+     *
+     * The final implementation resolves all compilation issues, maintains
+     * strict type safety, follows all established conventions, and delivers a
+     * production-ready test that accurately validates the intended API
+     * behaviors and user workflows. A null value signifies the draft correction
+     * was already optimal and requires no modifications.
+     *
+     * Workflow: Review integration → Final refinement → Production-ready
+     * implementation (or null if draft needs no changes). This is the ultimate
+     * deliverable that will replace the compilation-failed code when provided,
+     * otherwise the draft correction is used as-is.
+     */
+    final: string | null;
+  }
+}