@autobe/agent 0.28.0 → 0.29.0

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

@@ -1,39 +1,78 @@
 import { AutoBeOpenApi } from "@autobe/interface";
 
+import { IAutoBePreliminaryGetAnalysisFiles } from "../../common/structures/IAutoBePreliminaryGetAnalysisFiles";
+import { IAutoBePreliminaryGetInterfaceSchemas } from "../../common/structures/IAutoBePreliminaryGetInterfaceSchemas";
+import { IAutoBePreliminaryGetPrismaSchemas } from "../../common/structures/IAutoBePreliminaryGetPrismaSchemas";
+
 export interface IAutoBeInterfaceSchemaRelationReviewApplication {
   /**
-   * Reviews and validates DTO relations and structural patterns in OpenAPI
-   * schemas.
-   *
-   * This specialized relation review function focuses exclusively on data
-   * relations, foreign key transformations, and structural integrity. It
-   * ensures proper modeling of business domains while preventing circular
-   * references and enabling efficient code generation.
-   *
-   * The review process validates and corrects:
+   * Process schema relation review task or preliminary data requests.
    *
-   * - Relation classifications (Composition vs Association vs Aggregation)
-   * - Foreign key to object transformations in response DTOs
-   * - Actor reversal violations (e.g., User containing articles array)
-   * - Inline object extractions to named types with $ref
-   * - IInvert pattern applications for alternative perspectives
+   * Reviews and validates DTO relations and structural patterns, ensuring proper
+   * modeling of business domains with correct relation classifications, foreign
+   * key transformations, and structural integrity.
    *
-   * @param props Relation review results including violations found, fixes
-   *   applied, and modified schemas
+   * @param props Request containing either preliminary data request or complete
+   *   task
    */
-  review: (
-    props: IAutoBeInterfaceSchemaRelationReviewApplication.IProps,
-  ) => void;
+  process(props: IAutoBeInterfaceSchemaRelationReviewApplication.IProps): void;
 }
 
 export namespace IAutoBeInterfaceSchemaRelationReviewApplication {
+  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 (getAnalysisFiles, getPrismaSchemas, 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.
+     */
+    thinking: string;
+
+    /**
+     * Type discriminator for the request.
+     *
+     * Determines which action to perform: preliminary data retrieval
+     * (getAnalysisFiles, getPrismaSchemas, getInterfaceSchemas) or final schema
+     * relation review (complete). When preliminary returns empty array, that
+     * type is removed from the union, physically preventing repeated calls.
+     */
+    request:
+      | IComplete
+      | IAutoBePreliminaryGetAnalysisFiles
+      | IAutoBePreliminaryGetPrismaSchemas
+      | IAutoBePreliminaryGetInterfaceSchemas;
+  }
+
   /**
-   * Output structure for the relation review function.
+   * Request to review and validate schema relations.
    *
-   * Contains the relation analysis, structural fixes, and schemas modified for
-   * proper relations during the validation process.
+   * Executes relation review to ensure proper data relations, foreign key
+   * transformations, and structural integrity. Validates relation classifications,
+   * prevents circular references, and enables efficient code generation.
    */
-  export interface IProps {
+  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: "complete";
+
     /** Relation analysis and structural planning information. */
     think: IThink;
 
@@ -58,6 +97,12 @@ export namespace IAutoBeInterfaceSchemaRelationReviewApplication {
     content: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
   }
 
+  /**
+   * Structured thinking process for schema relation review.
+   *
+   * Contains analytical review findings and improvement action plan organized
+   * for systematic enhancement of the schemas.
+   */
   export interface IThink {
     /**
      * Relation and structural violation findings from the review process.

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

@@ -1,37 +1,79 @@
 import { AutoBeOpenApi } from "@autobe/interface";
 
+import { IAutoBePreliminaryGetAnalysisFiles } from "../../common/structures/IAutoBePreliminaryGetAnalysisFiles";
+import { IAutoBePreliminaryGetInterfaceSchemas } from "../../common/structures/IAutoBePreliminaryGetInterfaceSchemas";
+import { IAutoBePreliminaryGetPrismaSchemas } from "../../common/structures/IAutoBePreliminaryGetPrismaSchemas";
+
 export interface IAutoBeInterfaceSchemaSecurityReviewApplication {
   /**
-   * Reviews and validates OpenAPI schema definitions for security compliance.
-   *
-   * This specialized security review function focuses exclusively on
-   * authentication boundaries, data protection, and system integrity. It
-   * enforces strict security policies to prevent authentication bypass, data
-   * exposure, and unauthorized access.
-   *
-   * The review process identifies and removes:
+   * Process schema security review task or preliminary data requests.
    *
-   * - Authentication context fields in request DTOs (e.g., bbs_member_id)
-   * - Password and token fields in response DTOs
-   * - System-managed fields in request DTOs
-   * - Phantom fields that don't exist in Prisma schema
+   * Reviews and validates OpenAPI schema definitions for security compliance,
+   * enforcing strict policies to prevent authentication bypass, data exposure,
+   * and unauthorized access.
    *
-   * @param props Security review results including violations found, fixes
-   *   applied, and modified schemas
+   * @param props Request containing either preliminary data request or complete
+   *   task
    */
-  review: (
-    props: IAutoBeInterfaceSchemaSecurityReviewApplication.IProps,
-  ) => void;
+  process(props: IAutoBeInterfaceSchemaSecurityReviewApplication.IProps): void;
 }
 
 export namespace IAutoBeInterfaceSchemaSecurityReviewApplication {
+  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 (getAnalysisFiles, getPrismaSchemas, 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.
+     */
+    thinking: string;
+
+    /**
+     * Type discriminator for the request.
+     *
+     * Determines which action to perform: preliminary data retrieval
+     * (getAnalysisFiles, getPrismaSchemas, getInterfaceSchemas) or final schema
+     * security review (complete). When preliminary returns empty array, that
+     * type is removed from the union, physically preventing repeated calls.
+     */
+    request:
+      | IComplete
+      | IAutoBePreliminaryGetAnalysisFiles
+      | IAutoBePreliminaryGetPrismaSchemas
+      | IAutoBePreliminaryGetInterfaceSchemas;
+  }
+
   /**
-   * Output structure for the security review function.
+   * Request to review and validate schema security.
    *
-   * Contains the security analysis, remediation actions, and schemas modified
-   * for security compliance during the validation process.
+   * Executes security review to ensure schemas comply with authentication
+   * boundaries, data protection, and system integrity policies. Identifies and
+   * removes authentication context, passwords, tokens, system-managed fields, and
+   * phantom fields.
    */
-  export interface IProps {
+  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: "complete";
+
     /** Security analysis and remediation planning information. */
     think: IThink;
 
@@ -55,6 +97,12 @@ export namespace IAutoBeInterfaceSchemaSecurityReviewApplication {
     content: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
   }
 
+  /**
+   * Structured thinking process for schema security review.
+   *
+   * Contains analytical review findings and improvement action plan organized
+   * for systematic enhancement of the schemas.
+   */
   export interface IThink {
     /**
      * Security violation findings from the review process.

package/src/orchestrate/interface/utils/JsonSchemaFactory.ts

@@ -58,31 +58,39 @@ export namespace JsonSchemaFactory {
   };
 
   const removeUnused = (document: AutoBeOpenApi.IDocument): void => {
-    const used: Set<string> = new Set();
-    const visit = (schema: AutoBeOpenApi.IJsonSchema): void =>
-      OpenApiTypeChecker.visit({
-        components: { schemas: document.components.schemas },
-        schema,
-        closure: (next) => {
-          if (OpenApiTypeChecker.isReference(next)) {
-            const key: string = next.$ref.split("/").pop()!;
-            used.add(key);
-          }
-        },
-      });
-
-    for (const op of document.operations) {
-      if (op.requestBody !== null)
-        visit({
-          $ref: `#/components/schemas/${op.requestBody.typeName}`,
-        });
-      if (op.responseBody !== null)
-        visit({
-          $ref: `#/components/schemas/${op.responseBody.typeName}`,
+    while (true) {
+      const used: Set<string> = new Set();
+      const visit = (schema: AutoBeOpenApi.IJsonSchema): void =>
+        OpenApiTypeChecker.visit({
+          components: { schemas: document.components.schemas },
+          schema,
+          closure: (next) => {
+            if (OpenApiTypeChecker.isReference(next)) {
+              const key: string = next.$ref.split("/").pop()!;
+              used.add(key);
+            }
+          },
         });
+      for (const op of document.operations) {
+        if (op.requestBody !== null)
+          visit({
+            $ref: `#/components/schemas/${op.requestBody.typeName}`,
+          });
+        if (op.responseBody !== null)
+          visit({
+            $ref: `#/components/schemas/${op.responseBody.typeName}`,
+          });
+      }
+
+      const complete: boolean =
+        Object.keys(document.components.schemas).length === 0 ||
+        Object.keys(document.components.schemas).every(
+          (key) => used.has(key) === true,
+        );
+      if (complete === true) break;
+      for (const key of Object.keys(document.components.schemas))
+        if (used.has(key) === false) delete document.components.schemas[key];
     }
-    for (const key of Object.keys(document.components.schemas))
-      if (used.has(key) === false) delete document.components.schemas[key];
   };
 
   const removeDuplicated = (document: AutoBeOpenApi.IDocument): void => {

package/src/orchestrate/interface/utils/JsonSchemaNamingConvention.ts

@@ -4,80 +4,92 @@ import { OpenApiTypeChecker } from "@samchon/openapi";
 
 export namespace JsonSchemaNamingConvention {
   export const operations = (operations: AutoBeOpenApi.IOperation[]): void => {
-    const typeNames: Set<string> = new Set();
-    operate(typeNames, operations);
+    const convention: Convention = new Convention();
+    for (const op of operations) {
+      if (op.requestBody !== null)
+        convention.emplace(op.requestBody.typeName, (v) => {
+          if (op.requestBody !== null) op.requestBody.typeName = v;
+        });
+      if (op.responseBody !== null)
+        convention.emplace(op.responseBody.typeName, (v) => {
+          if (op.responseBody !== null) op.responseBody.typeName = v;
+        });
+    }
+    convention.execute();
   };
 
   export const schemas = (
     operations: AutoBeOpenApi.IOperation[],
     ...componentSchemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>[]
   ): void => {
-    const typeNames: Set<string> = new Set();
-    for (const schemas of componentSchemas)
-      for (const key of Object.keys(schemas)) typeNames.add(key);
-    const answer = operate(typeNames, operations);
-
-    for (const dict of componentSchemas)
-      for (const x of Object.keys(dict)) {
-        const y: string = answer(x);
-        if (x === y) continue;
-        dict[y] = dict[x]!;
-        delete dict[x];
-      }
-    for (const dict of componentSchemas)
-      for (const x of Object.values(dict)) {
-        OpenApiTypeChecker.visit({
-          components: { schemas: dict },
-          schema: x,
-          closure: (s) => {
-            if (OpenApiTypeChecker.isReference(s) === false) return;
-            s.$ref = `#/components/schemas/${answer(s.$ref.split("/").pop()!)}`;
-          },
-        });
-      }
-  };
-
-  const operate = (
-    typeNames: Set<string>,
-    operations: AutoBeOpenApi.IOperation[],
-  ): ((v: string) => string) => {
+    const convention: Convention = new Convention();
     for (const op of operations) {
-      if (op.requestBody) typeNames.add(op.requestBody.typeName);
-      if (op.responseBody) typeNames.add(op.responseBody.typeName);
+      if (op.requestBody !== null)
+        convention.emplace(op.requestBody.typeName, (v) => {
+          if (op.requestBody !== null) op.requestBody.typeName = v;
+        });
+      if (op.responseBody !== null)
+        convention.emplace(op.responseBody.typeName, (v) => {
+          if (op.responseBody !== null) op.responseBody.typeName = v;
+        });
     }
-    const answer = prepare(typeNames);
-    for (const op of operations) {
-      if (op.requestBody)
-        op.requestBody.typeName = answer(op.requestBody.typeName);
-      if (op.responseBody)
-        op.responseBody.typeName = answer(op.responseBody.typeName);
+    for (const schema of componentSchemas) {
+      for (const key of Object.keys(schema)) {
+        convention.emplace(key, (v) => {
+          if (key === v) return;
+          schema[v] = schema[key]!;
+          delete schema[key];
+        });
+        for (const value of Object.values(schema))
+          OpenApiTypeChecker.visit({
+            components: { schemas: schema },
+            schema: value,
+            closure: (s) => {
+              if (OpenApiTypeChecker.isReference(s) === false) return;
+              const key: string = s.$ref.split("/").pop()!;
+              convention.emplace(
+                key,
+                (v) => (s.$ref = `#/components/schemas/${v}`),
+              );
+            },
+          });
+      }
+      convention.execute();
     }
-    return answer;
   };
+}
 
-  const prepare = (typeNames: Set<string>): ((v: string) => string) => {
-    const similar: Map<string, string[]> = new Map();
-    const getKey = (v: string) => v.split(".")[0]!.toLowerCase();
-    const getValue = (v: string) => v.split(".")[0]!;
-    const emplace = (v: string) =>
-      MapUtil.take(similar, getKey(v), () => []).push(getValue(v));
+const countCapitalLetters = (str: string) => (str.match(/[A-Z]/g) || []).length;
 
-    for (const v of typeNames) emplace(v);
+class Convention {
+  private readonly dict: Map<string, Set<string>> = new Map();
+  private readonly closures: IClosure[] = [];
 
-    const solution: Map<string, string> = new Map();
-    for (const [key, values] of similar) {
-      if (values.length === 1) continue;
-      const winner: string = values.sort(
-        (a, b) => countCapitalLetters(b) - countCapitalLetters(a),
-      )[0]!;
-      solution.set(key, winner);
+  public emplace(key: string, setter: (v: string) => void): void {
+    this.closures.push({ value: key, setter });
+
+    const top: string = key.split(".")[0]!;
+    MapUtil.take(this.dict, top.toLowerCase(), () => new Set()).add(top);
+  }
+
+  public execute(): void {
+    const mapping: Map<string, string> = new Map();
+    for (const [key, value] of this.dict.entries())
+      mapping.set(
+        key,
+        Array.from(value).sort(
+          (a, b) => countCapitalLetters(b) - countCapitalLetters(a),
+        )[0]!,
+      );
+    for (const closure of this.closures) {
+      const elements: string[] = closure.value.split(".");
+      const value: string = mapping.get(elements[0]!.toLowerCase())!;
+      closure.setter([value, ...elements.slice(1)].join("."));
     }
-    return (v: string) => {
-      const key: string = getKey(v);
-      if (solution.has(key) === false) return v;
-      return [solution.get(key), ...v.split(".").slice(1)].join(".");
-    };
-  };
+  }
 }
 
-const countCapitalLetters = (str: string) => (str.match(/[A-Z]/g) || []).length;
+interface IClosure {
+  value: string;
+  setter: (v: string) => void;
+}

package/src/orchestrate/interface/utils/JsonSchemaValidator.ts

@@ -1,5 +1,6 @@
 import { AutoBeOpenApi } from "@autobe/interface";
 import { AutoBeOpenApiTypeChecker, StringUtil } from "@autobe/utils";
+import { OpenApiTypeChecker } from "@samchon/openapi";
 import { IValidation } from "typia";
 import { Escaper } from "typia/lib/utils/Escaper";
 
@@ -14,69 +15,93 @@ export namespace JsonSchemaValidator {
     validateAuthorization(props);
     validatePrismaSchema(props.errors);
     validateRecursive(props);
-    for (const key of Object.keys(props.schemas))
+    for (const key of Object.keys(props.schemas)) {
       validateKey({
         errors: props.errors,
-        path: props.path,
+        path: `${props.path}[${JSON.stringify(key)}]`,
         key,
       });
+      OpenApiTypeChecker.visit({
+        components: { schemas: props.schemas },
+        schema: props.schemas[key],
+        closure: (next, accessor) => {
+          if (OpenApiTypeChecker.isReference(next)) {
+            validateKey({
+              errors: props.errors,
+              path: `${accessor}.$ref`,
+              key: next.$ref.split("/").pop()!,
+              transform: (typeName) => `#/components/schemas/${typeName}`,
+            });
+          }
+        },
+        accessor: `${props.path}[${JSON.stringify(key)}]`,
+      });
+    }
   };
 
   export const validateKey = (props: {
     errors: IValidation.IError[];
-    path: string;
     key: string;
+    path: string;
+    transform?: (typeName: string) => string;
   }): void => {
+    const transform = props.transform ?? ((typeName: string) => typeName);
     const elements: string[] = props.key.split(".");
     if (elements.every(Escaper.variable) === false)
       props.errors.push({
-        path: `${props.path}[${JSON.stringify(props.key)}]`,
-        expected: "Valid variable name",
-        value: props.key,
+        path: props.path,
+        expected: StringUtil.trim`
+          Valid variable name
+
+          ${elements.map((s) => `- ${s}: ${Escaper.variable(s) ? "valid" : "invalid"}`).join("\n")}
+        `,
+        value: transform(props.key),
         description: StringUtil.trim`
           JSON schema type name must be a valid variable name.
 
           Even though JSON schema type name allows dot(.) character, but
           each segment separated by dot(.) must be a valid variable name.
 
-          Current key name ${JSON.stringify(props.key)} is not valid. Change
-          it to a valid variable name at the next time.
+          Current key name ${transform(JSON.stringify(props.key))} is not valid. 
+          Change it to a valid variable name at the next time.
         `,
       });
     if (props.key.endsWith(".IPage")) {
       const expected: string = `IPage${props.key.substring(0, props.key.length - 6)}`;
       props.errors.push({
-        path: `${props.path}[${JSON.stringify(props.key)}]`,
-        expected: `"IPage" must be followed by another interface name. Use ${JSON.stringify(expected)} instead.`,
-        value: props.key,
+        path: props.path,
+        expected: `"IPage" must be followed by another interface name. Use ${transform(JSON.stringify(expected))} instead.`,
+        value: transform(props.key),
         description: StringUtil.trim`
           "IPage" is a reserved type name for pagination response.
           The pagination data type name must be post-fixed after "IPage".
           
-          However, you've defined ${JSON.stringify(props.key)}, 
+          However, you've defined ${transform(JSON.stringify(props.key))}, 
           post-fixing ".IPage" after the pagination data type name.
 
           Change it to a valid pagination type name to be
-          ${JSON.stringify(expected)} at the next time. Note that,
-          this is not a recommendation, but an instruction you must follow.
+          ${transform(JSON.stringify(expected))} at the next time. 
+          Note that, this is not a recommendation, but an instruction you must follow.
         `,
       });
     } else if (props.key === "IPageIRequest")
       props.errors.push({
-        path: `${props.path}[${JSON.stringify(props.key)}]`,
+        path: props.path,
         expected: `"IPageIRequest" is a mistake. Use "IPage.IRequest" instead.`,
-        value: props.key,
+        value: transform(props.key),
         description: StringUtil.trim`
-          You've taken a mistake that defines "IPageIRequest" as a type name.
+          You've taken a mistake that defines "${transform("IPageIRequest")}" as a type name.
           However, as you've intended to define a pagination request type, 
-          the correct type name is "IPage.IRequest" instead of "IPageIRequest".
+          the correct type name is "${transform("IPage.IRequest")}" instead of "${transform("IPageIRequest")}".
 
-          Change it to "IPage.IRequest" at the next time.
+          Change it to "${transform("IPage.IRequest")}" at the next time.
         `,
       });
     else if (
       props.key.startsWith("IPage") &&
-      props.key.startsWith("IPageI") === false
+      props.key.startsWith("IPageI") === false &&
+      props.key !== "IPage.IPagination" &&
+      props.key !== "IPage.IRequest"
     ) {
       const expected: string = `IPage${props.key
         .substring(5)
@@ -84,9 +109,9 @@ export namespace JsonSchemaValidator {
         .map((s) => (s.startsWith("I") ? s : `I${s}`))
         .join(".")}`;
       props.errors.push({
-        path: `${props.path}[${JSON.stringify(props.key)}]`,
+        path: props.path,
         expected: `Interface name starting with 'I' even after 'IPage': ${JSON.stringify(expected)}`,
-        value: props.key,
+        value: transform(props.key),
         description: StringUtil.trim`
           JSON schema type name must be an interface name starting with 'I'.
           Even though JSON schema type name allows dot(.) character, but
@@ -106,18 +131,20 @@ export namespace JsonSchemaValidator {
         .map((s) => (s.startsWith("I") ? s : `I${s}`))
         .join(".");
       props.errors.push({
-        path: `${props.path}[${JSON.stringify(props.key)}]`,
+        path: props.path,
         expected: `Interface name starting with 'I': ${JSON.stringify(expected)}`,
-        value: props.key,
+        value: transform(props.key),
         description: StringUtil.trim`
           JSON schema type name must be an interface name starting with 'I'.
           Even though JSON schema type name allows dot(.) character, but
           each segment separated by dot(.) must be an interface name starting
           with 'I'.
 
-          Current key name ${JSON.stringify(props.key)} is not valid. Change
-          it to a valid interface name to be ${JSON.stringify(expected)}, 
+          Current key name ${transform(JSON.stringify(props.key))} is not valid. 
+          Change it to a valid interface name to be ${transform(JSON.stringify(expected))}, 
           or change it to another valid interface name at the next time.
+
+          Note that, this is not a recommendation, but an instruction you must follow.
         `,
       });
     }