@autobe/agent 0.30.4 → 0.30.5

package/lib/orchestrate/realize/structures/IAutoBeRealizeOperationCorrectApplication.d.ts

@@ -6,10 +6,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
      */
@@ -20,56 +16,24 @@ export declare 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 | IAutoBePreliminaryGetAnalysisSections | IAutoBePreliminaryGetDatabaseSchemas | IAutoBePreliminaryGetRealizeCollectors | 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. */
     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
@@ -77,43 +41,24 @@ export declare namespace IAutoBeRealizeOperationCorrectApplication {
          * - Database schema and API contract constraints
          */
         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;
     }
     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/lib/orchestrate/realize/structures/IAutoBeRealizeOperationWriteApplication.d.ts

@@ -3,26 +3,12 @@ import { IAutoBePreliminaryGetDatabaseSchemas } from "../../common/structures/IA
 import { IAutoBePreliminaryGetRealizeCollectors } from "../../common/structures/IAutoBePreliminaryGetRealizeCollectors";
 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
@@ -34,75 +20,36 @@ export declare 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 | IAutoBePreliminaryGetDatabaseSchemas | IAutoBePreliminaryGetAnalysisSections | IAutoBePreliminaryGetRealizeCollectors | 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. */
     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;
     }
     interface IReviseProps {
         /**
-         * Review and improvement suggestions.
-         *
-         * Identifies areas for improvement in the draft code, including:
+         * Identify improvements:
          *
          * - Type safety enhancements
          * - Database query optimizations
@@ -112,12 +59,8 @@ export declare 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/lib/orchestrate/realize/structures/IAutoBeRealizeTransformerCorrectApplication.d.ts

@@ -4,11 +4,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
      */
@@ -19,63 +14,31 @@ export declare 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. */
     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
@@ -83,150 +46,69 @@ export declare 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;
     }
     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;
     }