@autobe/agent 0.25.7 → 0.27.0

package/src/orchestrate/interface/orchestrateInterfaceSchemaRename.ts

@@ -0,0 +1,270 @@
+import { IAgenticaController } from "@agentica/core";
+import {
+  AutoBeInterfaceSchemaRefactor,
+  AutoBeInterfaceSchemaRenameEvent,
+  AutoBeOpenApi,
+  AutoBeProgressEventBase,
+} from "@autobe/interface";
+import {
+  ILlmApplication,
+  ILlmSchema,
+  OpenApi,
+  OpenApiTypeChecker,
+} from "@samchon/openapi";
+import { IPointer } from "tstl";
+import typia from "typia";
+import { v7 } from "uuid";
+
+import { AutoBeConfigConstant } from "../../constants/AutoBeConfigConstant";
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { assertSchemaModel } from "../../context/assertSchemaModel";
+import { divideArray } from "../../utils/divideArray";
+import { executeCachedBatch } from "../../utils/executeCachedBatch";
+import { transformInterfaceSchemaRenameHistories } from "./histories/transformInterfaceSchemaRenameHistories";
+import { IAutoBeInterfaceSchemaRenameApplication } from "./structures/IAutoBeInterfaceSchemaRenameApplication";
+
+export async function orchestrateInterfaceSchemaRename<
+  Mode extends ILlmSchema.Model,
+>(
+  ctx: AutoBeContext<Mode>,
+  document: AutoBeOpenApi.IDocument,
+  capacity: number = AutoBeConfigConstant.INTERFACE_CAPACITY * 10,
+): Promise<void> {
+  const tableNames: string[] = ctx
+    .state()
+    .prisma!.result.data.files.map((f) => f.models)
+    .flat()
+    .map((m) => m.name)
+    .filter((m) => m.startsWith("mv_") === false);
+  const entireTypeNames: Set<string> = new Set();
+  for (let name of Object.keys(document.components.schemas)) {
+    if (name.startsWith("IPage")) name = name.replace("IPage", "");
+    name = name.split(".")[0];
+    entireTypeNames.add(name);
+  }
+
+  const matrix: string[][] = divideArray({
+    array: Array.from(entireTypeNames),
+    capacity,
+  });
+  const progress: AutoBeProgressEventBase = {
+    total: entireTypeNames.size,
+    completed: 0,
+  };
+  const refactors: AutoBeInterfaceSchemaRefactor[] = uniqueRefactors(
+    (
+      await executeCachedBatch(
+        matrix.map(
+          (typeNames) => (promptCacheKey) =>
+            divideAndConquer(ctx, {
+              tableNames,
+              typeNames,
+              promptCacheKey,
+              progress,
+            }),
+        ),
+      )
+    ).flat(),
+  );
+  orchestrateInterfaceSchemaRename.rename(document, refactors);
+}
+export namespace orchestrateInterfaceSchemaRename {
+  export const rename = (
+    document: AutoBeOpenApi.IDocument,
+    refactors: AutoBeInterfaceSchemaRefactor[],
+  ): void => {
+    // REPLACE RULE
+    const replace = (typeName: string): string | null => {
+      // exact match
+      const exact: AutoBeInterfaceSchemaRefactor | undefined = refactors.find(
+        (r) => r.from === typeName,
+      );
+      if (exact !== undefined) return exact.to;
+
+      // T.X match
+      const prefix: AutoBeInterfaceSchemaRefactor | undefined = refactors.find(
+        (r) => typeName.startsWith(`${r.from}.`),
+      );
+      if (prefix !== undefined)
+        return typeName.replace(`${prefix.from}.`, `${prefix.to}.`);
+
+      // IPageT exact match
+      const pageExact: AutoBeInterfaceSchemaRefactor | undefined =
+        refactors.find((r) => typeName === `IPage${r.from}`);
+      if (pageExact !== undefined) return `IPage${pageExact.to}`;
+
+      // IPageT.X match
+      const pagePrefix: AutoBeInterfaceSchemaRefactor | undefined =
+        refactors.find((r) => typeName.startsWith(`IPage${r.from}.`));
+      if (pagePrefix !== undefined)
+        return typeName.replace(
+          `IPage${pagePrefix.from}.`,
+          `IPage${pagePrefix.to}.`,
+        );
+      return null;
+    };
+
+    // JSON SCHEMA REFERENCES
+    const $refChangers: Map<OpenApi.IJsonSchema, () => void> = new Map();
+    for (const value of Object.values(document.components.schemas))
+      OpenApiTypeChecker.visit({
+        components: document.components,
+        schema: value,
+        closure: (schema) => {
+          if (OpenApiTypeChecker.isReference(schema) === false) return;
+          const x: string = schema.$ref.split("/").pop()!;
+          const y: string | null = replace(x);
+          if (y !== null)
+            $refChangers.set(schema, () => {
+              schema.$ref = `#/components/schemas/${y}`;
+            });
+        },
+      });
+    for (const fn of $refChangers.values()) fn();
+
+    // COMPONENT SCHEMAS
+    for (const x of Object.keys(document.components.schemas)) {
+      const y: string | null = replace(x);
+      if (y !== null) {
+        document.components.schemas[y] = document.components.schemas[x];
+        delete document.components.schemas[x];
+      }
+    }
+
+    // OPERATIONS
+    for (const op of document.operations) {
+      if (op.requestBody)
+        op.requestBody.typeName =
+          replace(op.requestBody.typeName) ?? op.requestBody.typeName;
+      if (op.responseBody)
+        op.responseBody.typeName =
+          replace(op.responseBody.typeName) ?? op.responseBody.typeName;
+    }
+  };
+}
+
+const divideAndConquer = async <Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  props: {
+    tableNames: string[];
+    typeNames: string[];
+    promptCacheKey: string;
+    progress: AutoBeProgressEventBase;
+  },
+): Promise<AutoBeInterfaceSchemaRefactor[]> => {
+  try {
+    const pointer: IPointer<IAutoBeInterfaceSchemaRenameApplication.IProps | null> =
+      {
+        value: null,
+      };
+    const { metric, tokenUsage } = await ctx.conversate({
+      source: "interfaceSchemaRename",
+      controller: createController<Model>(
+        ctx.model,
+        (value) => (pointer.value = value),
+      ),
+      histories: transformInterfaceSchemaRenameHistories(props),
+      enforceFunctionCall: true,
+      promptCacheKey: props.promptCacheKey,
+      message: "Rename DTO type names for consistency and clarity.",
+    });
+    if (pointer.value === null) {
+      props.progress.completed += props.typeNames.length;
+      return [];
+    }
+
+    pointer.value.refactors = uniqueRefactors(pointer.value.refactors);
+    ctx.dispatch({
+      type: "interfaceSchemaRename",
+      id: v7(),
+      refactors: pointer.value.refactors,
+      total: props.progress.total,
+      completed: (props.progress.completed += props.typeNames.length),
+      metric,
+      tokenUsage,
+      created_at: new Date().toISOString(),
+    } satisfies AutoBeInterfaceSchemaRenameEvent);
+    return pointer.value.refactors;
+  } catch {
+    props.progress.completed += props.typeNames.length;
+    return [];
+  }
+};
+
+const uniqueRefactors = (
+  refactors: AutoBeInterfaceSchemaRefactor[],
+): AutoBeInterfaceSchemaRefactor[] => {
+  // Remove self-references (A->A)
+  refactors = refactors.filter((r) => r.from !== r.to);
+
+  // Remove duplicates (keep the first occurrence)
+  refactors = Array.from(new Map(refactors.map((r) => [r.from, r])).values());
+
+  // Build adjacency map: from -> to
+  const renameMap: Map<string, string> = new Map();
+  for (const r of refactors) {
+    renameMap.set(r.from, r.to);
+  }
+
+  // Resolve transitive chains: A->B, B->C becomes A->C
+  const resolveChain = (from: string): string => {
+    const visited: Set<string> = new Set();
+    let current: string = from;
+
+    while (renameMap.has(current)) {
+      // Cycle detection: A->B, B->C, C->A
+      if (visited.has(current)) {
+        // Cycle detected, keep the last valid mapping before cycle
+        return current;
+      }
+      visited.add(current);
+      current = renameMap.get(current)!;
+    }
+    return current;
+  };
+
+  // Build final refactor list with resolved chains
+  const resolved: Map<string, AutoBeInterfaceSchemaRefactor> = new Map();
+  for (const from of renameMap.keys()) {
+    const finalTo: string = resolveChain(from);
+    // Only include if actually changes
+    if (from !== finalTo) {
+      resolved.set(from, {
+        from,
+        to: finalTo,
+      });
+    }
+  }
+  return Array.from(resolved.values());
+};
+
+const createController = <Model extends ILlmSchema.Model>(
+  model: Model,
+  build: (value: IAutoBeInterfaceSchemaRenameApplication.IProps) => void,
+): IAgenticaController.IClass<Model> => {
+  assertSchemaModel(model);
+  const application: ILlmApplication<Model> = collection[
+    model === "chatgpt" ? "chatgpt" : "claude"
+  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
+  return {
+    protocol: "class",
+    name: "SchemaRenamer",
+    application,
+    execute: {
+      rename: (props) => {
+        build(props);
+      },
+    } satisfies IAutoBeInterfaceSchemaRenameApplication,
+  };
+};
+
+const collection = {
+  chatgpt: typia.llm.application<
+    IAutoBeInterfaceSchemaRenameApplication,
+    "chatgpt"
+  >(),
+  claude: typia.llm.application<
+    IAutoBeInterfaceSchemaRenameApplication,
+    "claude"
+  >(),
+};

package/src/orchestrate/interface/{orchestrateInterfaceSchemasReview.ts → orchestrateInterfaceSchemaReview.ts}

@@ -1,9 +1,6 @@
 import { IAgenticaController } from "@agentica/core";
-import {
-  AutoBeInterfaceSchemasReviewEvent,
-  AutoBeOpenApi,
-  AutoBeProgressEventBase,
-} from "@autobe/interface";
+import { AutoBeOpenApi, AutoBeProgressEventBase } from "@autobe/interface";
+import { AutoBeInterfaceSchemaReviewEvent } from "@autobe/interface/src/events/AutoBeInterfaceSchemaReviewEvent";
 import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
 import { OpenApiV3_1Emender } from "@samchon/openapi/lib/converters/OpenApiV3_1Emender";
 import { IPointer } from "tstl";
@@ -15,44 +12,62 @@ import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { divideArray } from "../../utils/divideArray";
 import { executeCachedBatch } from "../../utils/executeCachedBatch";
-import { transformInterfaceSchemasReviewHistories } from "./histories/transformInterfaceSchemasReviewHistories";
-import { IAutoBeInterfaceSchemasReviewApplication } from "./structures/IAutobeInterfaceSchemasReviewApplication";
+import { transformInterfaceSchemaReviewHistories } from "./histories/transformInterfaceSchemaReviewHistories";
+import { IAutoBeInterfaceSchemaContentReviewApplication } from "./structures/IAutoBeInterfaceSchemaContentReviewApplication";
 import { JsonSchemaFactory } from "./utils/JsonSchemaFactory";
 import { JsonSchemaNamingConvention } from "./utils/JsonSchemaNamingConvention";
 import { JsonSchemaValidator } from "./utils/JsonSchemaValidator";
 import { fulfillJsonSchemaErrorMessages } from "./utils/fulfillJsonSchemaErrorMessages";
 
-export async function orchestrateInterfaceSchemasReview<
+interface IConfig {
+  kind: AutoBeInterfaceSchemaReviewEvent["kind"];
+  systemPrompt: string;
+}
+
+export async function orchestrateInterfaceSchemaReview<
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
-  operations: AutoBeOpenApi.IOperation[],
-  schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>,
-  capacity: number = AutoBeConfigConstant.INTERFACE_CAPACITY,
+  config: IConfig,
+  props: {
+    document: AutoBeOpenApi.IDocument;
+    instruction: string;
+    progress: AutoBeProgressEventBase;
+  },
 ): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
-  const a = Object.entries(schemas).map(([key, schema]) => {
-    return { [key]: schema };
+  const typeNames: string[] = Object.keys(props.document.components.schemas);
+  const matrix: string[][] = divideArray({
+    array: typeNames,
+    capacity: AutoBeConfigConstant.INTERFACE_CAPACITY,
   });
-
-  const matrix: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>[][] =
-    divideArray({
-      array: a,
-      capacity,
-    });
-  const progress: IProgress = {
-    total: matrix.length,
-    completed: 0,
-  };
-
   const x: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> = {};
   for (const y of await executeCachedBatch(
     matrix.map((it) => async (promptCacheKey) => {
+      const operations: AutoBeOpenApi.IOperation[] =
+        props.document.operations.filter(
+          (op) =>
+            (op.requestBody && it.includes(op.requestBody.typeName)) ||
+            (op.responseBody && it.includes(op.responseBody.typeName)),
+        );
       const row: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
-        await divideAndConquer(ctx, operations, it, progress, promptCacheKey);
+        await divideAndConquer(ctx, config, {
+          instruction: props.instruction,
+          operations,
+          everySchemas: props.document.components.schemas,
+          reviewSchemas: it.reduce(
+            (acc, cur) => {
+              acc[cur] = props.document.components.schemas[cur];
+              return acc;
+            },
+            {} as Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>,
+          ),
+          progress: props.progress,
+          promptCacheKey,
+        });
       return row;
     }),
   )) {
-    JsonSchemaNamingConvention.schemas(operations, x, y);
+    JsonSchemaNamingConvention.schemas(props.document.operations, x, y);
     Object.assign(x, y);
   }
   return x;
@@ -60,46 +75,41 @@ export async function orchestrateInterfaceSchemasReview<
 
 async function divideAndConquer<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  operations: AutoBeOpenApi.IOperation[],
-  schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>[],
-  progress: AutoBeProgressEventBase,
-  promptCacheKey: string,
-): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
-  const schema = schemas.reduce((acc, cur) => Object.assign(acc, cur), {});
-  return step(ctx, operations, schema, progress, promptCacheKey);
-}
-
-export async function step<Model extends ILlmSchema.Model>(
-  ctx: AutoBeContext<Model>,
-  operations: AutoBeOpenApi.IOperation[],
-  schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>,
-  progress: AutoBeProgressEventBase,
-  promptCacheKey: string,
+  config: IConfig,
+  props: {
+    instruction: string;
+    operations: AutoBeOpenApi.IOperation[];
+    everySchemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
+    reviewSchemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
+    progress: AutoBeProgressEventBase;
+    promptCacheKey: string;
+  },
 ): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
   try {
-    const pointer: IPointer<IAutoBeInterfaceSchemasReviewApplication.IProps | null> =
+    const pointer: IPointer<IAutoBeInterfaceSchemaContentReviewApplication.IProps | null> =
       {
         value: null,
       };
-    const { tokenUsage } = await ctx.conversate({
-      source: "interfaceSchemasReview",
+    const { metric, tokenUsage } = await ctx.conversate({
+      source: "interfaceSchemaReview",
       controller: createController({
         model: ctx.model,
         pointer,
-        operations,
-        schemas,
       }),
-      histories: transformInterfaceSchemasReviewHistories(
-        ctx.state(),
-        operations,
-        schemas,
-      ),
+      histories: transformInterfaceSchemaReviewHistories({
+        state: ctx.state(),
+        systemPrompt: config.systemPrompt,
+        instruction: props.instruction,
+        operations: props.operations,
+        everySchemas: props.everySchemas,
+        reviewSchemas: props.reviewSchemas,
+      }),
       enforceFunctionCall: true,
-      promptCacheKey,
-      message: "Review type schemas.",
+      promptCacheKey: props.promptCacheKey,
+      message: "Review DTO content completeness and consistency.",
     });
     if (pointer.value === null) {
-      ++progress.completed;
+      ++props.progress.completed;
       return {};
     }
 
@@ -110,40 +120,42 @@ export async function step<Model extends ILlmSchema.Model>(
     ).schemas ?? {}) as Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
 
     ctx.dispatch({
-      type: "interfaceSchemasReview",
+      type: "interfaceSchemaReview",
+      kind: config.kind,
       id: v7(),
-      schemas: schemas,
+      schemas: props.reviewSchemas,
       review: pointer.value.think.review,
       plan: pointer.value.think.plan,
       content,
+      metric,
       tokenUsage,
       step: ctx.state().analyze?.step ?? 0,
-      total: progress.total,
-      completed: ++progress.completed,
+      total: props.progress.total,
+      completed: ++props.progress.completed,
       created_at: new Date().toISOString(),
-    } satisfies AutoBeInterfaceSchemasReviewEvent);
+    });
     return content;
   } catch {
-    ++progress.completed;
+    ++props.progress.completed;
     return {};
   }
 }
 
 function createController<Model extends ILlmSchema.Model>(props: {
   model: Model;
-  pointer: IPointer<IAutoBeInterfaceSchemasReviewApplication.IProps | null>;
-  operations: AutoBeOpenApi.IOperation[];
-  schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
+  pointer: IPointer<IAutoBeInterfaceSchemaContentReviewApplication.IProps | null>;
 }): IAgenticaController.IClass<Model> {
   assertSchemaModel(props.model);
 
   const validate = (
     next: unknown,
-  ): IValidation<IAutoBeInterfaceSchemasReviewApplication.IProps> => {
+  ): IValidation<IAutoBeInterfaceSchemaContentReviewApplication.IProps> => {
     JsonSchemaFactory.fixPage("content", next);
 
-    const result: IValidation<IAutoBeInterfaceSchemasReviewApplication.IProps> =
-      typia.validate<IAutoBeInterfaceSchemasReviewApplication.IProps>(next);
+    const result: IValidation<IAutoBeInterfaceSchemaContentReviewApplication.IProps> =
+      typia.validate<IAutoBeInterfaceSchemaContentReviewApplication.IProps>(
+        next,
+      );
     if (result.success === false) {
       fulfillJsonSchemaErrorMessages(result.errors);
       return result;
@@ -171,25 +183,31 @@ function createController<Model extends ILlmSchema.Model>(props: {
   ) satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
   return {
     protocol: "class",
-    name: "Reviewer",
+    name: "ContentReviewer",
     application,
     execute: {
       review: (input) => {
         props.pointer.value = input;
       },
-    } satisfies IAutoBeInterfaceSchemasReviewApplication,
+    } satisfies IAutoBeInterfaceSchemaContentReviewApplication,
   };
 }
 
 const collection = {
   chatgpt: (validate: Validator) =>
-    typia.llm.application<IAutoBeInterfaceSchemasReviewApplication, "chatgpt">({
+    typia.llm.application<
+      IAutoBeInterfaceSchemaContentReviewApplication,
+      "chatgpt"
+    >({
       validate: {
         review: validate,
       },
     }),
   claude: (validate: Validator) =>
-    typia.llm.application<IAutoBeInterfaceSchemasReviewApplication, "claude">({
+    typia.llm.application<
+      IAutoBeInterfaceSchemaContentReviewApplication,
+      "claude"
+    >({
       validate: {
         review: validate,
       },
@@ -198,9 +216,4 @@ const collection = {
 
 type Validator = (
   input: unknown,
-) => IValidation<IAutoBeInterfaceSchemasReviewApplication.IProps>;
-
-export interface IProgress {
-  total: number;
-  completed: number;
-}
+) => IValidation<IAutoBeInterfaceSchemaContentReviewApplication.IProps>;

package/src/orchestrate/interface/orchestrateInterfaceSchemas.ts

@@ -1,6 +1,6 @@
 import { IAgenticaController } from "@agentica/core";
 import {
-  AutoBeInterfaceSchemasEvent,
+  AutoBeInterfaceSchemaEvent,
   AutoBeOpenApi,
   AutoBeProgressEventBase,
 } from "@autobe/interface";
@@ -59,13 +59,18 @@ export async function orchestrateInterfaceSchemas<
   };
   for (const y of await executeCachedBatch(
     matrix.map((it) => async (promptCacheKey) => {
+      const operations: AutoBeOpenApi.IOperation[] = props.operations.filter(
+        (op) =>
+          (op.requestBody && it.includes(op.requestBody.typeName)) ||
+          (op.responseBody && it.includes(op.responseBody.typeName)),
+      );
       const row: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
         await divideAndConquer(ctx, {
-          instruction: props.instruction,
-          operations: props.operations,
-          typeNames: it,
+          operations,
           progress,
           promptCacheKey,
+          typeNames: it,
+          instruction: props.instruction,
         });
       return row;
     }),
@@ -128,10 +133,13 @@ async function process<Model extends ILlmSchema.Model>(
   > | null> = {
     value: null,
   };
-  const { tokenUsage } = await ctx.conversate({
-    source: "interfaceSchemas",
+  const { metric, tokenUsage } = await ctx.conversate({
+    source: "interfaceSchema",
     histories: transformInterfaceSchemaHistories({
       state: ctx.state(),
+      typeNames: Array.from(
+        new Set([...props.remained, ...Object.keys(props.oldbie)]),
+      ),
       operations: props.operations,
       instruction: props.instruction,
     }),
@@ -154,7 +162,7 @@ async function process<Model extends ILlmSchema.Model>(
       too.
 
       ${Array.from(props.remained)
-        .map((k) => `      - \`${k}\``)
+        .map((k) => `- \`${k}\``)
         .join("\n")}${
         already.length !== 0
           ? StringUtil.trim`
@@ -176,9 +184,10 @@ async function process<Model extends ILlmSchema.Model>(
     }) as AutoBeOpenApi.IComponents
   ).schemas ?? {}) as Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
   ctx.dispatch({
-    type: "interfaceSchemas",
+    type: "interfaceSchema",
     id: v7(),
     schemas,
+    metric,
     tokenUsage,
     completed: (props.progress.completed += Object.keys(schemas).length),
     total: (props.progress.total += Object.keys(schemas).filter(
@@ -186,7 +195,7 @@ async function process<Model extends ILlmSchema.Model>(
     ).length),
     step: ctx.state().prisma?.step ?? 0,
     created_at: new Date().toISOString(),
-  } satisfies AutoBeInterfaceSchemasEvent);
+  } satisfies AutoBeInterfaceSchemaEvent);
   return schemas;
 }