@autobe/agent 0.30.4 → 0.30.5

package/src/orchestrate/interface/structures/IAutoBeInterfaceSchemaCastingApplication.ts

@@ -10,65 +10,26 @@ import { IAutoBePreliminaryGetPreviousInterfaceOperations } from "../../common/s
 import { IAutoBePreliminaryGetPreviousInterfaceSchemas } from "../../common/structures/IAutoBePreliminaryGetPreviousInterfaceSchemas";
 
 /**
- * Application interface for the Schema Refine agent.
- *
- * The Schema Refine agent detects and corrects degenerate type aliases where
- * complex data structures have been incorrectly simplified to primitive types
- * (`string`, `number`, `boolean`, `integer`).
- *
- * This agent analyzes JSDoc descriptions, database schema hints, and naming
- * conventions to identify mismatches between documented semantics and actual
- * type definitions, then provides corrected object schema definitions.
+ * Detects and corrects degenerate type aliases (primitives that should be
+ * objects).
  */
 export interface IAutoBeInterfaceSchemaCastingApplication {
-  /**
-   * Process schema refinement task or preliminary data requests.
-   *
-   * Analyzes a potentially degenerate primitive type alias and determines
-   * whether it should be refined into a proper object schema structure. Uses
-   * Chain-of-Thought reasoning to systematically evaluate the type.
-   *
-   * @param props Request containing either preliminary data request or
-   *   refinement completion
-   */
+  /** Process task or retrieve preliminary data. */
   process(props: IAutoBeInterfaceSchemaCastingApplication.IProps): void;
 }
 
 export namespace IAutoBeInterfaceSchemaCastingApplication {
-  /** Properties for schema refinement processing. */
+  /** Properties for schema casting processing. */
   export interface IProps {
     /**
-     * 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.
-     *
-     * This reflection helps you avoid duplicate requests and premature
-     * completion.
+     * Reasoning about your current state: what's missing (preliminary) or what
+     * you accomplished (completion).
      */
     thinking: string;
 
     /**
-     * Type discriminator for the request.
-     *
-     * Determines which action to perform: preliminary data retrieval
-     * (getAnalysisSections, getDatabaseSchemas, getInterfaceOperations,
-     * getInterfaceSchemas, etc.) or final refinement decision (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.
      */
     request:
       | IComplete
@@ -83,70 +44,31 @@ export namespace IAutoBeInterfaceSchemaCastingApplication {
   }
 
   /**
-   * Request to complete schema refinement analysis.
-   *
-   * Executes the final refinement decision after analyzing a potentially
-   * degenerate primitive type. Uses structured Chain-of-Thought reasoning
-   * through observation, reasoning, and verdict properties to ensure systematic
-   * evaluation before making a decision.
+   * Complete schema casting analysis via Chain-of-Thought (observation,
+   * reasoning, verdict).
    */
   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 refinement
-     * decision request.
-     */
+    /** Type discriminator for completion request. */
     type: "complete";
 
     /**
-     * Observation of the current type and its documentation.
-     *
-     * Describe what you observe about the type being analyzed:
-     *
-     * - What is the current type definition? (e.g., `type IFoo = number`)
-     * - What does the JSDoc/description say about the type?
-     * - Are there any database schema hints (JSON field, etc.)?
-     * - What does the naming suggest? (e.g., "Distribution", "Preferences")
-     *
-     * This is purely descriptive - state facts without judgment.
+     * Factual observation of the current type definition, JSDoc, schema hints,
+     * and naming.
      */
     observation: string;
 
-    /**
-     * Reasoning about whether the type is degenerate.
-     *
-     * Analyze the observations and explain your reasoning:
-     *
-     * - Does the documentation describe a structure that contradicts the
-     *   primitive type?
-     * - Are there keywords suggesting complex structure? (key/value, array, list,
-     *   contains, mapping)
-     * - Is this a legitimate semantic alias? (e.g., `IUserId = string`)
-     * - What type SHOULD this be based on the evidence?
-     */
+    /** Reasoning about whether documentation contradicts the primitive type. */
     reasoning: string;
 
     /**
-     * Final verdict on whether to refine the type.
-     *
-     * State your conclusion clearly:
-     *
-     * - Is this a degenerate type that needs refinement, or a valid primitive?
-     * - Summarize the key evidence that led to this decision.
-     * - If refining, briefly describe what the correct type should be.
+     * Final verdict: "degenerate" (needs casting to object) or "valid
+     * primitive".
      */
     verdict: string;
 
     /**
-     * Casting design for the corrected object schema, or `null` if intentional.
-     *
-     * When the type is degenerate: provide the casting design with corrected
-     * object schema containing `databaseSchema`, `specification`,
-     * `description`, and `schema` fields.
-     *
-     * When the type is intentional (valid primitive alias): set to `null`.
+     * Corrected object schema casting design, or `null` if the primitive is
+     * intentional.
      */
     casting: AutoBeInterfaceSchemaCasting | null;
   }

package/src/orchestrate/interface/structures/IAutoBeInterfaceSchemaComplementApplication.ts

@@ -10,54 +10,21 @@ import { IAutoBePreliminaryGetPreviousInterfaceOperations } from "../../common/s
 import { IAutoBePreliminaryGetPreviousInterfaceSchemas } from "../../common/structures/IAutoBePreliminaryGetPreviousInterfaceSchemas";
 
 export interface IAutoBeInterfaceSchemaComplementApplication {
-  /**
-   * Process schema complement task or preliminary data requests.
-   *
-   * Adds missing schema definitions to ensure OpenAPI document is complete and
-   * all referenced schemas are properly defined.
-   *
-   * @param props Request containing either preliminary data request or complete
-   *   task
-   */
+  /** Process task or retrieve preliminary data. */
   process(props: IAutoBeInterfaceSchemaComplementApplication.IProps): void;
 }
 
 export namespace IAutoBeInterfaceSchemaComplementApplication {
   export interface IProps {
     /**
-     * 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.
-     *
-     * This reflection helps you avoid duplicate requests and premature
-     * completion.
+     * Reasoning about your current state: what's missing (preliminary) or what
+     * you accomplished (completion).
      */
     thinking: string;
 
     /**
-     * Type discriminator for the request.
-     *
-     * Determines which action to perform: preliminary data retrieval
-     * (getAnalysisSections, getDatabaseSchemas, getInterfaceOperations,
-     * getInterfaceSchemas, getPreviousAnalysisSections,
-     * getPreviousDatabaseSchemas, getPreviousInterfaceOperations,
-     * getPreviousInterfaceSchemas) or final schema complementation (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.
      */
     request:
       | IComplete
@@ -71,52 +38,20 @@ export namespace IAutoBeInterfaceSchemaComplementApplication {
       | IAutoBePreliminaryGetPreviousInterfaceSchemas;
   }
 
-  /**
-   * Request to add a missing schema definition.
-   *
-   * Executes schema complementation to fill in a referenced but undefined
-   * schema type in the OpenAPI document's components.schemas section. Ensures
-   * the $ref reference resolves to a valid schema definition.
-   */
+  /** Add a missing schema definition referenced by $ref in components.schemas. */
   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";
 
-    /**
-     * Analysis of the missing type's purpose and context.
-     *
-     * Before designing the schema, analyze what you know:
-     *
-     * - What is this missing type for? Why is it referenced?
-     * - Where is it referenced from? ($ref in which schemas/operations?)
-     * - What does the reference context tell us about its expected structure?
-     * - Are there similar types that provide structural hints?
-     */
+    /** Analysis of the missing type's purpose and reference context. */
     analysis: string;
 
-    /**
-     * Rationale for the schema design decisions.
-     *
-     * Explain why you designed the schema this way:
-     *
-     * - Which properties did you include and why?
-     * - What is required vs optional, and why?
-     * - Which types use $ref and why?
-     * - What was excluded and why? (e.g., auto-generated fields for ICreate)
-     */
+    /** Rationale for the schema design decisions. */
     rationale: string;
 
     /**
-     * Design structure for the missing schema being complemented.
-     *
-     * Contains `databaseSchema`, `specification`, `description`, and `schema`
-     * fields that together define a complete DTO type component.
+     * Schema design: database mapping, specification, description, and JSON
+     * Schema.
      */
     design: AutoBeInterfaceSchemaDesign;
   }

package/src/orchestrate/interface/structures/IAutoBeInterfaceSchemaRefineApplication.ts

@@ -13,29 +13,13 @@ import { IAutoBePreliminaryGetPreviousInterfaceOperations } from "../../common/s
 import { IAutoBePreliminaryGetPreviousInterfaceSchemas } from "../../common/structures/IAutoBePreliminaryGetPreviousInterfaceSchemas";
 
 /**
- * Function calling interface for enriching pure JSON Schema with documentation
- * and metadata.
- *
- * Guides the AI agent through adding `databaseSchemaProperty`, `specification`,
- * and `description` to each property in a schema that was initially generated
- * with only type structure. The refinement process ensures complete and
- * accurate schema definitions that properly map to database entities.
- *
- * The refinement follows a structured RAG workflow: preliminary context
- * gathering (analysis sections, database schemas, interface operations)
- * followed by property-level enrichment operations.
- *
- * @author Samchon
+ * Enriches JSON Schema properties with databaseSchemaProperty, specification,
+ * and description.
  */
 export interface IAutoBeInterfaceSchemaRefineApplication {
   /**
    * Process schema refinement task or preliminary data requests.
    *
-   * Enriches OpenAPI schema definitions with documentation and metadata that
-   * were omitted during initial generation. Processes property-level additions
-   * including database field mappings, implementation specifications, and API
-   * consumer descriptions.
-   *
    * @param props Request containing either preliminary data request or complete
    *   task
    */
@@ -46,35 +30,17 @@ export namespace IAutoBeInterfaceSchemaRefineApplication {
     /**
      * 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):
+     * For preliminary requests: what critical information is missing and why?
+     * Be brief — state the gap, don't list everything you have.
      *
-     * - 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 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
-     * (getAnalysisSections, getDatabaseSchemas, getInterfaceOperations,
-     * getInterfaceSchemas) or final schema refinement (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
@@ -88,93 +54,45 @@ export namespace IAutoBeInterfaceSchemaRefineApplication {
       | IAutoBePreliminaryGetPreviousInterfaceSchemas;
   }
 
-  /**
-   * Complete schema refinement with object-level and property-level enrichment.
-   *
-   * Executes the refinement to add documentation and metadata to a schema.
-   * Includes both object-level context (databaseSchema, specification,
-   * description) and property-level operations (depict, create, update,
-   * erase).
-   */
+  /** Complete schema refinement with object-level and property-level enrichment. */
   export interface IComplete {
-    /**
-     * Type discriminator for the request.
-     *
-     * Value "complete" indicates this is the final task execution request after
-     * all preliminary data has been gathered.
-     */
+    /** Type discriminator for completion request. */
     type: "complete";
 
-    /**
-     * Summary of refinement analysis and actions taken.
-     *
-     * Documents the agent's analysis of the schema's current state, including
-     * which properties need documentation, any structural issues discovered,
-     * and the overall assessment of what enrichment was performed.
-     */
+    /** Summary of refinement analysis and actions taken. */
     review: string;
 
     /**
-     * Database schema context for the type.
-     *
-     * Specifies which database table or entity this schema maps to, providing
-     * context for property-level database field mappings. This establishes the
-     * source of truth for data validation and transformation logic.
-     *
-     * Set to `null` for schemas that don't directly map to a single database
-     * table (e.g., computed aggregations, cross-table joins, utility types).
+     * Database table this schema maps to, or `null` for non-table types
+     * (aggregations, joins, utility).
      */
     databaseSchema: string | null;
 
     /**
-     * Specification for the schema implementation.
-     *
-     * Documents HOW the schema should be implemented, including data source
-     * mappings, transformation rules, and technical implementation details.
-     *
-     * **MANDATORY**: You must always provide this value, even if the existing
-     * specification is correct. This forces explicit review and strengthens
-     * reasoning about the implementation details.
+     * HOW the schema should be implemented (data source mappings,
+     * transformation rules). **MANDATORY**: Always provide, even if existing
+     * value is correct — this forces explicit review of implementation
+     * details.
      */
     specification: string;
 
     /**
-     * Description for API consumers.
-     *
-     * Documents WHAT the schema represents for API consumers, explaining the
-     * purpose and usage of this data type in the API context.
-     *
-     * **MANDATORY**: You must always provide this value, even if the existing
-     * description is correct. This forces explicit review and strengthens
-     * reasoning about the API documentation.
+     * WHAT the schema represents for API consumers. **MANDATORY**: Always
+     * provide, even if existing value is correct — this forces explicit review
+     * of consumer-facing documentation.
      */
     description: string;
 
     /**
-     * Database properties explicitly excluded from this DTO.
-     *
-     * Declare every database property that intentionally does not appear in
-     * this DTO. Together with `revises`, this must cover every database
-     * property — each one must appear in exactly one of the two arrays.
+     * Database properties explicitly excluded from this DTO. Together with
+     * `revises`, must cover every database property exactly once.
      */
     excludes: AutoBeInterfaceSchemaPropertyExclude[];
 
     /**
-     * Property-level refinement operations for DTO properties.
-     *
-     * Every DTO property must appear exactly once with one of:
-     *
-     * - `depict`: Add documentation to existing property
-     * - `create`: Add missing property with documentation
-     * - `update`: Fix incorrect type and add documentation
-     * - `erase`: Remove invalid property
-     *
-     * Each operation includes the property key, reason for the action, and
-     * complete metadata including `databaseSchemaProperty`, `specification`,
-     * and `description`.
-     *
-     * Database properties are addressed either here (via
-     * `databaseSchemaProperty`) or in `excludes`. No property can be omitted.
+     * Property-level refinement operations (depict/create/update/erase). Every
+     * DTO property must appear exactly once. Database properties go here (via
+     * `databaseSchemaProperty`) or in `excludes`. No omissions allowed.
      */
     revises: AutoBeInterfaceSchemaPropertyRefine[];
   }

package/src/orchestrate/interface/structures/IAutoBeInterfaceSchemaRenameApplication.ts

@@ -2,43 +2,17 @@ import { AutoBeInterfaceSchemaRefactor } from "@autobe/interface";
 
 export interface IAutoBeInterfaceSchemaRenameApplication {
   /**
-   * Analyze DTO type names and identify naming violations.
-   *
-   * This method examines existing DTO type names to detect violations of the
-   * CRITICAL naming rule: ALL words from the database table name MUST be
-   * preserved in the DTO type name. Omitting intermediate words breaks
-   * type-to-table traceability and causes system failures.
-   *
-   * The method receives a list of database table names and current DTO type
-   * names, then identifies which type names incorrectly omit service prefixes
-   * or intermediate components from their corresponding table names.
-   *
-   * @param props Properties containing refactoring operations to fix naming
-   *   violations.
+   * Identify DTO type names that violate the naming rule: ALL words from the
+   * database table name MUST be preserved in the DTO type name.
    */
   rename(props: IAutoBeInterfaceSchemaRenameApplication.IProps): void;
 }
 export namespace IAutoBeInterfaceSchemaRenameApplication {
   export interface IProps {
     /**
-     * List of refactoring operations to rename incorrectly named DTO types.
-     *
-     * Each refactor specifies:
-     *
-     * - `from`: The current INCORRECT type name (e.g., "ISale", "IBbsComment")
-     * - `to`: The CORRECT type name with all components preserved (e.g.,
-     *   "IShoppingSale", "IBbsArticleComment")
-     *
-     * IMPORTANT: Only include type names that violate the naming rules. If a
-     * type name correctly preserves all components from the table name, do NOT
-     * include it in the refactors list.
-     *
-     * The orchestrator will automatically handle:
-     *
-     * - Renaming the base type (e.g., ISale → IShoppingSale)
-     * - Renaming all variants (e.g., ISale.ICreate → IShoppingSale.ICreate)
-     * - Renaming page types (e.g., IPageISale → IPageIShoppingSale)
-     * - Updating all $ref references throughout the OpenAPI document
+     * Refactoring operations for incorrectly named DTO types. Only include
+     * violations. Orchestrator auto-handles variants, page types, and $ref
+     * updates.
      */
     refactors: AutoBeInterfaceSchemaRefactor[];
   }

package/src/orchestrate/interface/structures/IAutoBeInterfaceSchemaReviewApplication.ts

@@ -13,51 +13,20 @@ import { IAutoBePreliminaryGetPreviousInterfaceOperations } from "../../common/s
 import { IAutoBePreliminaryGetPreviousInterfaceSchemas } from "../../common/structures/IAutoBePreliminaryGetPreviousInterfaceSchemas";
 
 export interface IAutoBeInterfaceSchemaReviewApplication {
-  /**
-   * Process schema review task or preliminary data requests.
-   *
-   * Reviews and validates OpenAPI schema definitions to ensure quality,
-   * correctness, and compliance with domain requirements and system policies.
-   *
-   * @param props Request containing either preliminary data request or complete
-   *   task
-   */
+  /** Process task or retrieve preliminary data. */
   process(props: IAutoBeInterfaceSchemaReviewApplication.IProps): void;
 }
 export namespace IAutoBeInterfaceSchemaReviewApplication {
   export interface IProps {
     /**
-     * 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.
-     *
-     * This reflection helps you avoid duplicate requests and premature
-     * completion.
+     * Reasoning about your current state: what's missing (preliminary) or what
+     * you accomplished (completion).
      */
     thinking: string;
 
     /**
-     * Type discriminator for the request.
-     *
-     * Determines which action to perform: preliminary data retrieval
-     * (getAnalysisSections, getDatabaseSchemas, getInterfaceOperations,
-     * getInterfaceSchemas) or final schema review (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.
      */
     request:
       | IComplete
@@ -73,12 +42,7 @@ export namespace IAutoBeInterfaceSchemaReviewApplication {
 
   /** Complete schema review with property-level revisions. */
   export interface IComplete {
-    /**
-     * Type discriminator for the request.
-     *
-     * Value "complete" indicates this is the final review submission after all
-     * preliminary data has been gathered.
-     */
+    /** Type discriminator for completion request. */
     type: "complete";
 
     /** Summary of issues found and fixes applied. */