@autobe/agent 0.30.4 → 0.30.5

package/src/orchestrate/realize/structures/IAutoBeRealizeOperationCorrectApplication.ts

@@ -7,10 +7,6 @@ export interface IAutoBeRealizeOperationCorrectApplication {
   /**
    * Process provider correction task or preliminary data requests.
    *
-   * Systematically analyzes and corrects TypeScript compilation errors through
-   * three-phase workflow (think → draft → revise). Maintains business logic
-   * integrity while resolving all compilation issues.
-   *
    * @param props Request containing either preliminary data request or complete
    *   task
    */
@@ -22,34 +18,16 @@ export namespace IAutoBeRealizeOperationCorrectApplication {
     /**
      * Think before you act.
      *
-     * Before requesting preliminary data or completing your task, reflect on
-     * your current state and explain your reasoning:
-     *
-     * For preliminary requests (getAnalysisSections, getDatabaseSchemas, etc.):
-     *
-     * - What critical information is missing that you don't already have?
-     * - Why do you need it specifically right now?
-     * - Be brief - state the gap, don't list everything you have.
+     * For preliminary requests: what critical information is missing and why?
      *
-     * For completion (complete):
-     *
-     * - What key assets did you acquire?
-     * - What did you accomplish?
-     * - Why is it sufficient to complete?
-     * - Summarize - don't enumerate every single item.
-     *
-     * This reflection helps you avoid duplicate requests and premature
-     * completion.
+     * For completion: what did you acquire, what did you accomplish, why is it
+     * sufficient? Summarize — don't enumerate every single item.
      */
     thinking: string;
 
     /**
-     * Type discriminator for the request.
-     *
-     * Determines which action to perform: preliminary data retrieval
-     * (getDatabaseSchemas) or final error correction (complete). When
-     * preliminary returns empty array, that type is removed from the union,
-     * physically preventing repeated calls.
+     * Action to perform. Exhausted preliminary types are removed from the
+     * union, physically preventing repeated calls.
      */
     request:
       | IComplete
@@ -59,27 +37,13 @@ export namespace IAutoBeRealizeOperationCorrectApplication {
       | IAutoBePreliminaryGetRealizeTransformers;
   }
 
-  /**
-   * Request to correct provider implementation errors.
-   *
-   * Executes three-phase error correction to resolve TypeScript compilation
-   * issues in provider functions. Applies systematic fixes following think →
-   * draft → revise pattern to ensure error-free production code.
-   */
+  /** Correct provider compilation errors via think/draft/revise. */
   export interface IComplete {
-    /**
-     * Type discriminator for the request.
-     *
-     * Determines which action to perform: preliminary data retrieval or actual
-     * task execution. Value "complete" indicates this is the final task
-     * execution request.
-     */
+    /** Type discriminator for completion request. */
     type: "complete";
 
     /**
-     * Initial error analysis and correction strategy.
-     *
-     * Analyzes TypeScript compilation errors to understand:
+     * Error analysis and correction strategy. Understand:
      *
      * - Error patterns and root causes
      * - Required fixes and their impact
@@ -88,46 +52,27 @@ export namespace IAutoBeRealizeOperationCorrectApplication {
      */
     think: string;
 
-    /**
-     * First correction attempt.
-     *
-     * Implements the initial fixes identified in the think phase. For simple
-     * errors (typos, missing imports), this may be the final solution. Complex
-     * errors may require further refinement.
-     */
+    /** Corrected implementation applying all fixes from think phase. */
     draft: string;
 
-    /**
-     * Revision and finalization phase.
-     *
-     * Reviews the draft corrections and produces the final, error-free code
-     * that maintains all business requirements.
-     */
+    /** Reviews draft corrections and produces final error-free code. */
     revise: IReviseProps;
   }
 
   export interface IReviseProps {
     /**
-     * Correction review and validation.
-     *
-     * Analyzes the draft corrections to ensure:
+     * Verify corrections:
      *
-     * - All TypeScript errors are resolved
+     * - All TypeScript errors resolved
      * - Business logic remains intact
-     * - AutoBE coding standards are maintained
-     * - No new errors are introduced
-     * - Performance and security are preserved
+     * - No new errors introduced
+     * - Performance and security preserved
      */
     review: string;
 
     /**
-     * Final error-free implementation.
-     *
-     * The complete, corrected code that passes all TypeScript compilation
-     * checks.
-     *
-     * Returns `null` if the draft corrections are sufficient and need no
-     * further changes.
+     * Final error-free code with all corrections applied, or null if draft
+     * needs no changes.
      */
     final: string | null;
   }

package/src/orchestrate/realize/structures/IAutoBeRealizeOperationWriteApplication.ts

@@ -4,26 +4,12 @@ import { IAutoBePreliminaryGetRealizeCollectors } from "../../common/structures/
 import { IAutoBePreliminaryGetRealizeTransformers } from "../../common/structures/IAutoBePreliminaryGetRealizeTransformers";
 
 /**
- * Function calling interface for generating API operation implementation
- * functions.
- *
- * Guides the AI agent through creating provider functions that implement
- * complete business logic for specific API endpoints. Each operation function
- * handles the full request-response lifecycle including validation,
- * authorization, database operations, and response formatting.
- *
- * The generation follows a structured RAG workflow: preliminary context
- * gathering (database schemas) → implementation planning → code generation →
- * review and refinement.
+ * Generates provider functions implementing business logic for API endpoints
+ * via plan/draft/revise workflow.
  */
 export interface IAutoBeRealizeOperationWriteApplication {
   /**
-   * Process operation function implementation task or preliminary data
-   * requests.
-   *
-   * Generates complete operation function implementation through three-phase
-   * workflow (plan → draft → revise). Ensures type safety, proper database
-   * query patterns, and API contract compliance.
+   * Process operation function generation task or preliminary data requests.
    *
    * @param props Request containing either preliminary data request or complete
    *   task
@@ -36,35 +22,16 @@ export namespace IAutoBeRealizeOperationWriteApplication {
     /**
      * Think before you act.
      *
-     * Before requesting preliminary data or completing your task, reflect on
-     * your current state and explain your reasoning:
-     *
-     * For preliminary requests (getAnalysisSections, getDatabaseSchemas, etc.):
-     *
-     * - What critical information is missing that you don't already have?
-     * - Why do you need it specifically right now?
-     * - Be brief - state the gap, don't list everything you have.
-     *
-     * For completion (complete):
-     *
-     * - What key assets did you acquire?
-     * - What did you accomplish?
-     * - Why is it sufficient to complete?
-     * - Summarize - don't enumerate every single item.
+     * For preliminary requests: what critical information is missing and why?
      *
-     * This reflection helps you avoid duplicate requests and premature
-     * completion.
+     * For completion: what key assets did you acquire, what did you accomplish,
+     * why is it sufficient? Summarize — don't enumerate every single item.
      */
     thinking: string;
 
     /**
-     * Type discriminator for the request.
-     *
-     * Determines which action to perform: preliminary data retrieval
-     * (getDatabaseSchemas, getRealizeCollectors, getRealizeTransformers) or
-     * final implementation generation (complete). When preliminary returns
-     * empty array, that type is removed from the union, physically preventing
-     * repeated calls.
+     * Action to perform. Exhausted preliminary types are removed from the
+     * union, physically preventing repeated calls.
      */
     request:
       | IComplete
@@ -74,48 +41,28 @@ export namespace IAutoBeRealizeOperationWriteApplication {
       | IAutoBePreliminaryGetRealizeTransformers;
   }
 
-  /**
-   * Request to generate operation function implementation.
-   *
-   * Executes three-phase generation to create complete operation
-   * implementation. Follows plan → draft → revise pattern to ensure type
-   * safety, proper database query patterns, and API contract compliance.
-   */
+  /** Generate operation implementation via plan/draft/revise. */
   export interface IComplete {
     /** Type discriminator for completion request. */
     type: "complete";
 
     /**
-     * Operation implementation plan and strategy.
-     *
-     * Analyzes the operation function requirements, identifies related database
-     * schemas, and outlines the implementation approach. Includes schema
+     * Operation implementation plan. Analyze requirements, identify related
+     * database schemas, and outline implementation approach including schema
      * validation and API contract verification.
      */
     plan: string;
 
-    /**
-     * Initial implementation draft.
-     *
-     * The first complete implementation attempt based on the plan. May contain
-     * areas that need refinement in the review phase.
-     */
+    /** First complete implementation attempt based on the plan. */
     draft: string;
 
-    /**
-     * Revision and finalization phase.
-     *
-     * Reviews the draft implementation and produces the final code with all
-     * improvements and corrections applied.
-     */
+    /** Reviews draft and produces final code. */
     revise: IReviseProps;
   }
 
   export interface IReviseProps {
     /**
-     * Review and improvement suggestions.
-     *
-     * Identifies areas for improvement in the draft code, including:
+     * Identify improvements:
      *
      * - Type safety enhancements
      * - Database query optimizations
@@ -126,12 +73,8 @@ export namespace IAutoBeRealizeOperationWriteApplication {
     review: string;
 
     /**
-     * Final operation function code.
-     *
-     * The complete, production-ready implementation with all review suggestions
-     * applied.
-     *
-     * Returns `null` if the draft is already perfect and needs no changes.
+     * Final operation function code with all review improvements applied, or
+     * null if draft needs no changes.
      */
     final: string | null;
   }

package/src/orchestrate/realize/structures/IAutoBeRealizeTransformerCorrectApplication.ts

@@ -9,11 +9,6 @@ export interface IAutoBeRealizeTransformerCorrectApplication {
   /**
    * Process transformer correction task or preliminary data requests.
    *
-   * Systematically analyzes and corrects TypeScript compilation errors in
-   * transformer functions through three-phase workflow (think → draft →
-   * revise). Maintains business logic integrity while resolving all compilation
-   * issues.
-   *
    * @param props Request containing either preliminary data request or complete
    *   task
    */
@@ -25,66 +20,34 @@ export namespace IAutoBeRealizeTransformerCorrectApplication {
     /**
      * Think before you act.
      *
-     * Before requesting preliminary data or completing your task, reflect on
-     * your current state and explain your reasoning:
-     *
-     * For preliminary requests (getDatabaseSchemas):
-     *
-     * - What critical information is missing that you don't already have?
-     * - Why do you need it specifically right now?
-     * - Be brief - state the gap, don't list everything you have.
-     *
-     * For completion (complete):
-     *
-     * - What key assets did you acquire?
-     * - What did you accomplish?
-     * - Why is it sufficient to complete?
-     * - Summarize - don't enumerate every single item.
+     * For preliminary requests: what critical information is missing?
      *
-     * This reflection helps you avoid duplicate requests and premature
-     * completion.
+     * For completion: what did you acquire, what did you accomplish, why is it
+     * sufficient? Summarize — don't enumerate every single item.
      */
     thinking: string;
 
     /**
-     * Type discriminator for the request.
-     *
-     * Determines which action to perform: preliminary data retrieval
-     * (getDatabaseSchemas) or final error correction (complete). When
-     * preliminary returns empty array, that type is removed from the union,
-     * physically preventing repeated calls.
+     * Action to perform. Exhausted preliminary types are removed from the
+     * union, physically preventing repeated calls.
      */
     request: IComplete | IAutoBePreliminaryGetDatabaseSchemas;
   }
 
-  /**
-   * Request to correct transformer implementation errors.
-   *
-   * Executes three-phase error correction to resolve TypeScript compilation
-   * issues in transformer functions. Applies systematic fixes following think →
-   * draft → revise pattern to ensure error-free production code.
-   */
+  /** Correct transformer compilation errors via think/draft/revise. */
   export interface IComplete {
-    /**
-     * Type discriminator for the request.
-     *
-     * Determines which action to perform: preliminary data retrieval or actual
-     * task execution. Value "complete" indicates this is the final task
-     * execution request.
-     */
+    /** Type discriminator for completion request. */
     type: "complete";
 
     /**
-     * Systematic error analysis and correction strategy.
-     *
-     * MUST contain thorough analysis with these four mandatory sections:
+     * Systematic error analysis. MUST contain four sections:
      *
-     * 1. Error Inventory - Categorize ALL compilation errors by root cause type
-     * 2. Root Cause Analysis - Identify WHY each error occurs (wrong field, wrong
+     * 1. Error Inventory — categorize ALL compilation errors by root cause
+     * 2. Root Cause Analysis — identify WHY each error occurs (wrong field, wrong
      *    transform, etc.)
-     * 3. Schema Verification - Cross-check error-related fields against actual
+     * 3. Schema Verification — cross-check error-related fields against actual
      *    database schema
-     * 4. Correction Strategy - Specific fix for each error in BOTH select() and
+     * 4. Correction Strategy — specific fix for each error in BOTH select() and
      *    transform()
      *
      * This forces you to understand the REAL problem (not guess) and plan
@@ -93,155 +56,74 @@ export namespace IAutoBeRealizeTransformerCorrectApplication {
     think: string;
 
     /**
-     * Database field-by-field selection mapping verification for the select()
-     * function.
+     * Selection mapping verification for select(). For each database field
+     * needed by transform(), document:
      *
-     * Review which database fields/relations are being selected to identify
-     * missing selections or incorrect field names that cause compilation
-     * errors.
-     *
-     * For each database field needed by transform(), document:
-     *
-     * - `member`: Exact database field/relation name (snake_case) - verify
-     *   against schema
-     * - `kind`: Whether it's a scalar field, belongsTo, hasOne, or hasMany
-     *   relation
-     * - `nullable`: Whether the field/relation is nullable (true/false for
-     *   scalar/belongsTo, null for hasMany/hasOne)
+     * - `member`: Exact Prisma field/relation name (snake_case) — verify against
+     *   the Relation Mapping Table and member list
+     * - `kind`: scalar, belongsTo, hasOne, or hasMany
+     * - `nullable`: true/false for scalar/belongsTo, null for hasMany/hasOne
      * - `how`: Current state + correction plan ("No change needed", "Fix: wrong
      *   field name", etc.)
      *
-     * The `kind` property helps identify selection syntax errors (e.g., using
-     * `field: true` for a relation instead of nested select).
-     *
-     * The `nullable` property helps catch nullability mismatch errors in
-     * transform().
-     *
      * **Common selection errors to identify**:
      *
      * - Wrong field name (typo or doesn't exist in schema)
-     * - Missing required field (transform() uses it but select() doesn't fetch
-     *   it)
-     * - Wrong selection syntax (true for relation, or nested select for scalar)
-     * - Selecting field that doesn't exist in database model
-     * - Missing aggregation (_count, _sum) when transform() needs it
+     * - Missing required field (transform() uses it but select() doesn't)
+     * - Wrong syntax (true for relation, or nested select for scalar)
      *
-     * This structured verification:
-     *
-     * - Catches missing field selections before runtime
-     * - Identifies field name typos by comparing with schema
-     * - Ensures select() provides all data transform() needs
-     * - Documents what corrections are needed for selection logic
-     * - Prevents "field not found" errors
-     *
-     * The validator will cross-check this against the database schema to ensure
-     * all field names are valid and complete coverage.
-     *
-     * **Note**: If compilation succeeds, select() is typically correct. This
-     * mapping is mainly for cases where select() has errors (wrong field names,
-     * missing selections).
+     * Missing even a single required field will cause validation failure.
      */
     selectMappings: AutoBeRealizeTransformerSelectMapping[];
 
     /**
-     * DTO property-by-property mapping verification for the transform()
-     * function.
-     *
-     * Review EVERY property from the DTO type definition to ensure correct
-     * transformation in the transform() function. This systematic approach
-     * catches errors beyond what the compiler reports and prevents new issues.
-     *
-     * For each DTO property in transform(), document:
+     * Transform mapping verification. MUST include EVERY DTO property.
      *
      * - `property`: Exact DTO property name (camelCase)
      * - `how`: Current state + correction plan ("No change needed", "Fix:
-     *   [problem] → [solution]", etc.)
-     *
-     * Even properties without errors should be included with "No change needed"
-     * to ensure complete review. Missing even a single property could hide
-     * bugs.
-     *
-     * This structured verification:
-     *
-     * - Catches silent errors compiler didn't report
-     * - Ensures no properties accidentally omitted in transform()
-     * - Documents transformation corrections explicitly
-     * - Verifies transform() logic correctness
-     * - Prevents regression in working transformations
-     *
-     * **Common correction scenarios in transform()**:
+     *   [problem] → [solution]")
      *
-     * - Missing type conversion (Decimal → Number, DateTime → ISO)
-     * - Wrong property name (DTO vs database mismatch)
-     * - Inline transformation when neighbor transformer exists
-     * - Missing computed property
-     * - Wrong nullable handling (DateTime? → string | null)
-     * - Fabricated property not in DTO
-     * - Missing property from DTO
-     * - Missing await for async transformers
+     * Even correct properties must be included with "No change needed" to
+     * ensure complete review.
      *
-     * The validator will cross-check this against the DTO type definition to
-     * ensure nothing was overlooked.
-     *
-     * **Note**: This mapping is ONLY for the transform() function. The select()
-     * function is typically correct if compilation succeeds, as it's
-     * structurally simpler.
+     * Missing even a single property will cause validation failure.
      */
     transformMappings: AutoBeRealizeTransformerTransformMapping[];
 
     /**
-     * Initial correction implementation.
-     *
-     * Complete corrected code that applies ALL fixes from the think phase
-     * strategy. EVERY error in think Section 1 inventory MUST be addressed.
-     * Implement:
+     * Complete corrected code. EVERY error from think Section 1 MUST be
+     * addressed. Implement:
      *
      * - Field name corrections in select() (exact database field names)
      * - Type casts in transform() (Decimal→Number, DateTime→ISO)
      * - Neighbor transformer reuse (replace inline logic if transformer exists)
-     * - Function order fix (transform → select → Payload)
      *
-     * Apply fixes surgically - change ONLY what's broken, preserve working
+     * Apply fixes surgically — change ONLY what's broken, preserve working
      * logic.
      */
     draft: string;
 
-    /**
-     * Revision and finalization phase.
-     *
-     * Reviews the draft corrections and produces the final, error-free code
-     * that maintains all business requirements.
-     */
+    /** Reviews draft corrections and produces final error-free code. */
     revise: IReviseProps;
   }
 
   export interface IReviseProps {
     /**
-     * Critical correction review and validation.
-     *
-     * MUST systematically verify using four checklists:
+     * MUST systematically verify four checklists:
      *
-     * 1. Error Resolution - Confirm EVERY error from think Section 1 is fixed
-     * 2. Root Cause Fix - Verify fixes address root causes (not workarounds/hacks)
-     * 3. System Rules - Mandatory neighbor reuse, select (not include), proper
-     *    types
-     * 4. No Regression - Confirm no NEW errors, Payload type matches select()
+     * 1. Error Resolution — confirm EVERY error from think Section 1 is fixed
+     * 2. Root Cause Fix — verify fixes address root causes (not workarounds/hacks)
+     * 3. System Rules — neighbor reuse, select (not include), proper types
+     * 4. No Regression — confirm no NEW errors, Payload type matches select()
      *
-     * Identify any remaining issues with line numbers and root cause analysis.
      * Catch Band-Aid fixes (any casts, type assertions) that hide real
      * problems.
      */
     review: string;
 
     /**
-     * Final error-free transformer code with all corrections applied.
-     *
-     * Apply ALL remaining fixes identified in the review to produce
-     * compilation-ready code. If review found issues (workarounds, new errors),
-     * this MUST contain proper fixes.
-     *
-     * Return `null` ONLY if draft is already perfect and review found zero
-     * issues.
+     * Final error-free code with all corrections applied, or null if draft
+     * needs no changes.
      */
     final: string | null;
   }