@autobe/agent 0.30.4 → 0.30.5

package/lib/orchestrate/interface/structures/IAutoBeInterfaceSchemaCastingApplication.d.ts

@@ -8,127 +8,49 @@ import { IAutoBePreliminaryGetPreviousDatabaseSchemas } from "../../common/struc
 import { IAutoBePreliminaryGetPreviousInterfaceOperations } from "../../common/structures/IAutoBePreliminaryGetPreviousInterfaceOperations";
 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 declare namespace IAutoBeInterfaceSchemaCastingApplication {
-    /** Properties for schema refinement processing. */
+    /** Properties for schema casting processing. */
     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 | IAutoBePreliminaryGetAnalysisSections | IAutoBePreliminaryGetDatabaseSchemas | IAutoBePreliminaryGetInterfaceOperations | IAutoBePreliminaryGetInterfaceSchemas | IAutoBePreliminaryGetPreviousAnalysisSections | IAutoBePreliminaryGetPreviousDatabaseSchemas | IAutoBePreliminaryGetPreviousInterfaceOperations | IAutoBePreliminaryGetPreviousInterfaceSchemas;
     }
     /**
-     * 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).
      */
     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/lib/orchestrate/interface/structures/IAutoBeInterfaceSchemaComplementApplication.d.ts

@@ -8,98 +8,33 @@ import { IAutoBePreliminaryGetPreviousDatabaseSchemas } from "../../common/struc
 import { IAutoBePreliminaryGetPreviousInterfaceOperations } from "../../common/structures/IAutoBePreliminaryGetPreviousInterfaceOperations";
 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 declare namespace IAutoBeInterfaceSchemaComplementApplication {
     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 | IAutoBePreliminaryGetAnalysisSections | IAutoBePreliminaryGetDatabaseSchemas | IAutoBePreliminaryGetInterfaceOperations | IAutoBePreliminaryGetInterfaceSchemas | IAutoBePreliminaryGetPreviousAnalysisSections | IAutoBePreliminaryGetPreviousDatabaseSchemas | IAutoBePreliminaryGetPreviousInterfaceOperations | 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. */
     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/lib/orchestrate/interface/structures/IAutoBeInterfaceSchemaRefineApplication.d.ts

@@ -8,29 +8,13 @@ import { IAutoBePreliminaryGetPreviousDatabaseSchemas } from "../../common/struc
 import { IAutoBePreliminaryGetPreviousInterfaceOperations } from "../../common/structures/IAutoBePreliminaryGetPreviousInterfaceOperations";
 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
      */
@@ -41,118 +25,52 @@ export declare 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 | IAutoBePreliminaryGetAnalysisSections | IAutoBePreliminaryGetDatabaseSchemas | IAutoBePreliminaryGetInterfaceOperations | IAutoBePreliminaryGetInterfaceSchemas | IAutoBePreliminaryGetPreviousAnalysisSections | IAutoBePreliminaryGetPreviousDatabaseSchemas | IAutoBePreliminaryGetPreviousInterfaceOperations | 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. */
     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/lib/orchestrate/interface/structures/IAutoBeInterfaceSchemaRenameApplication.d.ts

@@ -1,43 +1,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 declare namespace IAutoBeInterfaceSchemaRenameApplication {
     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/lib/orchestrate/interface/structures/IAutoBeInterfaceSchemaReviewApplication.d.ts

@@ -8,61 +8,25 @@ import { IAutoBePreliminaryGetPreviousDatabaseSchemas } from "../../common/struc
 import { IAutoBePreliminaryGetPreviousInterfaceOperations } from "../../common/structures/IAutoBePreliminaryGetPreviousInterfaceOperations";
 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 declare namespace IAutoBeInterfaceSchemaReviewApplication {
     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 | IAutoBePreliminaryGetAnalysisSections | IAutoBePreliminaryGetDatabaseSchemas | IAutoBePreliminaryGetInterfaceOperations | IAutoBePreliminaryGetInterfaceSchemas | IAutoBePreliminaryGetPreviousAnalysisSections | IAutoBePreliminaryGetPreviousDatabaseSchemas | IAutoBePreliminaryGetPreviousInterfaceOperations | IAutoBePreliminaryGetPreviousInterfaceSchemas;
     }
     /** Complete schema review with property-level revisions. */
     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. */
         review: string;