@autobe/agent 0.28.0 → 0.29.0

package/src/orchestrate/interface/histories/{transformInterfaceGroupHistories.ts → transformInterfaceComplementHistory.ts}

@@ -1,39 +1,46 @@
-import { IAgenticaHistoryJson } from "@agentica/core";
 import { StringUtil } from "@autobe/utils";
 import { v7 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
 import { AutoBeState } from "../../../context/AutoBeState";
-import { transformInterfaceAssetHistories } from "./transformInterfaceAssetHistories";
-import { transformInterfaceCommonHistories } from "./transformInterfaceCommonHistories";
+import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
+import { AutoBePreliminaryController } from "../../common/AutoBePreliminaryController";
 
-export const transformInterfaceGroupHistories = (props: {
+export const transformInterfaceComplementHistory = (props: {
   state: AutoBeState;
   instruction: string;
-}): Array<
-  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
-> => {
-  const prerequisite = transformInterfaceCommonHistories(props.state);
-  if (prerequisite !== null) return prerequisite;
-
-  return [
+  missed: string[];
+  preliminary: AutoBePreliminaryController<
+    | "analysisFiles"
+    | "prismaSchemas"
+    | "interfaceOperations"
+    | "interfaceSchemas"
+  >;
+}): IAutoBeOrchestrateHistory => ({
+  histories: [
     {
+      type: "systemMessage",
       id: v7(),
       created_at: new Date().toISOString(),
-      type: "systemMessage",
-      text: AutoBeSystemPromptConstant.INTERFACE_ENDPOINT,
+      text: AutoBeSystemPromptConstant.INTERFACE_OPERATION,
     },
-    ...transformInterfaceAssetHistories(props.state),
+    ...props.preliminary.getHistories(),
     {
+      type: "systemMessage",
       id: v7(),
       created_at: new Date().toISOString(),
-      type: "systemMessage",
-      text: AutoBeSystemPromptConstant.INTERFACE_GROUP,
+      text: AutoBeSystemPromptConstant.INTERFACE_SCHEMA,
     },
     {
+      type: "systemMessage",
       id: v7(),
       created_at: new Date().toISOString(),
+      text: AutoBeSystemPromptConstant.INTERFACE_COMPLEMENT,
+    },
+    {
       type: "assistantMessage",
+      id: v7(),
+      created_at: new Date().toISOString(),
       text: StringUtil.trim`
         ## API Design Instructions
 
@@ -42,16 +49,23 @@ export const transformInterfaceGroupHistories = (props: {
         such as endpoint patterns, request/response formats, DTO schemas,
         and operation specifications.
 
-        Follow these instructions when organizing API endpoints.
+        Follow these instructions when completing missing schema types.
         Carefully distinguish between:
         - Suggestions or recommendations (consider these as guidance)
         - Direct specifications or explicit commands (these must be followed exactly)
-        
-        When instructions contain direct specifications or explicit design decisions, 
+
+        When instructions contain direct specifications or explicit design decisions,
         follow them precisely even if you believe you have better alternatives.
 
         ${props.instruction}
+
+        ## Missed Types
+
+        You AI have missed below schema types:
+
+        ${props.missed.map((s) => `- ${s}`).join("\n")}
       `,
     },
-  ];
-};
+  ],
+  userMessage: "Complete the missing schema types please",
+});

package/src/orchestrate/interface/histories/transformInterfaceEndpointHistory.ts

@@ -0,0 +1,74 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import { AutoBeInterfaceGroup } from "@autobe/interface/src/histories/contents/AutoBeInterfaceGroup";
+import { StringUtil } from "@autobe/utils";
+import { v7 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeState } from "../../../context/AutoBeState";
+import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
+import { AutoBePreliminaryController } from "../../common/AutoBePreliminaryController";
+
+export const transformInterfaceEndpointHistory = (props: {
+  state: AutoBeState;
+  group: AutoBeInterfaceGroup;
+  authorizations: AutoBeOpenApi.IOperation[];
+  preliminary: AutoBePreliminaryController<"analysisFiles" | "prismaSchemas">;
+  instruction: string;
+}): IAutoBeOrchestrateHistory => ({
+  histories: [
+    {
+      type: "systemMessage",
+      id: v7(),
+      created_at: new Date().toISOString(),
+      text: AutoBeSystemPromptConstant.INTERFACE_ENDPOINT,
+    },
+    ...props.preliminary.getHistories(),
+    {
+      type: "assistantMessage",
+      id: v7(),
+      created_at: new Date().toISOString(),
+      text: StringUtil.trim`
+        ## API Design Instructions
+
+        The following API-specific instructions were extracted from
+        the user's requirements. These focus on API interface design aspects
+        such as endpoint patterns, request/response formats, DTO schemas,
+        and operation specifications.
+
+        Follow these instructions when designing endpoints for the ${props.group.name} group.
+        Carefully distinguish between:
+        - Suggestions or recommendations (consider these as guidance)
+        - Direct specifications or explicit commands (these must be followed exactly)
+
+        When instructions contain direct specifications or explicit design decisions,
+        follow them precisely even if you believe you have better alternatives.
+
+        ${props.instruction}
+
+        ## Group Information
+
+        Here is the target group for the endpoints:
+
+        \`\`\`json
+        ${JSON.stringify(props.group)}
+        \`\`\`
+
+        ## Already Existing Operations
+
+        These operations already exist. Do NOT create similar endpoints:
+
+        \`\`\`json
+        ${JSON.stringify(
+          props.authorizations.map((op) => ({
+            path: op.path,
+            method: op.method,
+            name: op.name,
+            summary: op.summary,
+          })),
+        )}
+        \`\`\`
+      `,
+    },
+  ],
+  userMessage: `Design endpoints for the ${props.group.name} group please`,
+});

package/src/orchestrate/interface/histories/transformInterfaceEndpointReviewHistory.ts

@@ -0,0 +1,40 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import { v7 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
+import { AutoBePreliminaryController } from "../../common/AutoBePreliminaryController";
+
+export const transformInterfaceEndpointReviewHistory = (props: {
+  preliminary: AutoBePreliminaryController<"analysisFiles" | "prismaSchemas">;
+  endpoints: AutoBeOpenApi.IEndpoint[];
+}): IAutoBeOrchestrateHistory => ({
+  histories: [
+    {
+      type: "systemMessage",
+      id: v7(),
+      created_at: new Date().toISOString(),
+      text: AutoBeSystemPromptConstant.INTERFACE_ENDPOINT,
+    },
+    {
+      id: v7(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.INTERFACE_ENDPOINT_REVIEW,
+      created_at: new Date().toISOString(),
+    },
+    ...props.preliminary.getHistories(),
+    {
+      id: v7(),
+      type: "assistantMessage",
+      text: [
+        "Below are endpoints generated by your request.",
+        "",
+        "```json",
+        JSON.stringify(props.endpoints),
+        "```",
+      ].join("\n"),
+      created_at: new Date().toISOString(),
+    },
+  ],
+  userMessage: "Review the generated endpoints please",
+});

package/src/orchestrate/interface/histories/transformInterfaceGroupHistory.ts

@@ -0,0 +1,72 @@
+import { StringUtil } from "@autobe/utils";
+import { v7 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeState } from "../../../context/AutoBeState";
+import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
+import { transformInterfaceCommonHistory } from "./transformInterfaceCommonHistory";
+
+export const transformInterfaceGroupHistory = (props: {
+  state: AutoBeState;
+  instruction: string;
+}): IAutoBeOrchestrateHistory => {
+  const prerequisite = transformInterfaceCommonHistory(props.state);
+  if (prerequisite !== null)
+    return {
+      histories: prerequisite,
+      userMessage: "Please wait for prerequisites to complete",
+    };
+
+  return {
+    histories: [
+      {
+        id: v7(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: AutoBeSystemPromptConstant.INTERFACE_GROUP,
+      },
+      {
+        id: v7(),
+        created_at: new Date().toISOString(),
+        type: "assistantMessage",
+        text: StringUtil.trim`
+          ## Requirement Analysis Report
+
+          \`\`\`json
+          ${JSON.stringify(props.state.analyze!.files)}
+          \`\`\`
+
+          ## Prisma DB Schemas
+
+          \`\`\`json
+          ${JSON.stringify(props.state.prisma!.schemas)}
+          \`\`\`
+        `,
+      },
+      {
+        id: v7(),
+        created_at: new Date().toISOString(),
+        type: "assistantMessage",
+        text: StringUtil.trim`
+          ## API Design Instructions
+
+          The following API-specific instructions were extracted from
+          the user's requirements. These focus on API interface design aspects
+          such as endpoint patterns, request/response formats, DTO schemas,
+          and operation specifications.
+
+          Follow these instructions when organizing API endpoints.
+          Carefully distinguish between:
+          - Suggestions or recommendations (consider these as guidance)
+          - Direct specifications or explicit commands (these must be followed exactly)
+
+          When instructions contain direct specifications or explicit design decisions,
+          follow them precisely even if you believe you have better alternatives.
+
+          ${props.instruction}
+        `,
+      },
+    ],
+    userMessage: "Design API endpoint groups please",
+  };
+};

package/src/orchestrate/interface/histories/transformInterfaceOperationHistory.ts

@@ -0,0 +1,79 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+import { v7 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
+import { AutoBePreliminaryController } from "../../common/AutoBePreliminaryController";
+
+export const transformInterfaceOperationHistory = (props: {
+  prefix: string;
+  endpoints: AutoBeOpenApi.IEndpoint[];
+  preliminary: AutoBePreliminaryController<"analysisFiles" | "prismaSchemas">;
+  instruction: string;
+}): IAutoBeOrchestrateHistory => {
+  return {
+    histories: [
+      {
+        type: "systemMessage",
+        id: v7(),
+        created_at: new Date().toISOString(),
+        text: AutoBeSystemPromptConstant.INTERFACE_OPERATION,
+      },
+      ...props.preliminary.getHistories(),
+      {
+        type: "systemMessage",
+        id: v7(),
+        created_at: new Date().toISOString(),
+        text: StringUtil.trim`
+          ## Service Prefix
+          - Original: ${props.prefix}
+          - PascalCase for DTOs: ${props.prefix
+            .split(/[-_]/)
+            .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
+            .join("")}
+          - Expected DTO pattern: I${props.prefix
+            .split(/[-_]/)
+            .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
+            .join("")}{EntityName}
+        `,
+      },
+      {
+        type: "assistantMessage",
+        id: v7(),
+        created_at: new Date().toISOString(),
+        text: StringUtil.trim`
+          ## API Design Instructions
+
+          The following API-specific instructions were extracted from
+          the user's requirements. These focus on API interface design aspects
+          such as endpoint patterns, request/response formats, DTO schemas,
+          and operation specifications.
+
+          Follow these instructions when designing operation specifications.
+          Carefully distinguish between:
+          - Suggestions or recommendations (consider these as guidance)
+          - Direct specifications or explicit commands (these must be followed exactly)
+
+          When instructions contain direct specifications or explicit design decisions,
+          follow them precisely even if you believe you have better alternatives.
+
+          ${props.instruction}
+
+          ## Operations
+
+          You have to make API operations for the given endpoints:
+
+          \`\`\`json
+          ${JSON.stringify(props.endpoints)}
+          \`\`\`
+
+          If there is a content in the failure, it is to explain why it failed before.
+          Please supplement or modify the Operation accordingly.
+        `,
+      },
+    ],
+    userMessage:
+      "Create API operation specifications for the given endpoints please",
+  };
+};

package/src/orchestrate/interface/histories/transformInterfaceOperationReviewHistory.ts

@@ -0,0 +1,43 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+import { v7 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
+import { AutoBePreliminaryController } from "../../common/AutoBePreliminaryController";
+
+export function transformInterfaceOperationReviewHistory(props: {
+  preliminary: AutoBePreliminaryController<"analysisFiles" | "prismaSchemas">;
+  operations: AutoBeOpenApi.IOperation[];
+}): IAutoBeOrchestrateHistory {
+  return {
+    histories: [
+      {
+        type: "systemMessage",
+        id: v7(),
+        created_at: new Date().toISOString(),
+        text: AutoBeSystemPromptConstant.INTERFACE_OPERATION,
+      },
+      ...props.preliminary.getHistories(),
+      {
+        type: "systemMessage",
+        id: v7(),
+        created_at: new Date().toISOString(),
+        text: AutoBeSystemPromptConstant.INTERFACE_OPERATION_REVIEW,
+      },
+      {
+        type: "assistantMessage",
+        id: v7(),
+        created_at: new Date().toISOString(),
+        text: StringUtil.trim`
+          Review the following API operations:
+
+          \`\`\`json
+          ${JSON.stringify(props.operations)}
+          \`\`\`
+        `,
+      },
+    ],
+    userMessage: "Review the following API operations please",
+  };
+}

package/src/orchestrate/interface/histories/transformInterfacePrerequisiteHistory.ts

@@ -0,0 +1,89 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+import { OpenApiTypeChecker } from "@samchon/openapi";
+import { v7 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
+import { AutoBePreliminaryController } from "../../common/AutoBePreliminaryController";
+import { getReferenceIds } from "../../test/utils/getReferenceIds";
+
+// @todo -> RAG
+export const transformInterfacePrerequisiteHistory = (props: {
+  document: AutoBeOpenApi.IDocument;
+  includes: AutoBeOpenApi.IOperation[];
+  preliminary: AutoBePreliminaryController<
+    | "analysisFiles"
+    | "prismaSchemas"
+    | "interfaceOperations"
+    | "interfaceSchemas"
+  >;
+}): IAutoBeOrchestrateHistory => {
+  const domainSchemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
+    {};
+  const visit = (key: string) =>
+    OpenApiTypeChecker.visit({
+      schema: {
+        $ref: `#/components/schemas/${key}`,
+      },
+      components: props.document.components,
+      closure: (next) => {
+        if (OpenApiTypeChecker.isReference(next))
+          domainSchemas[next.$ref.split("/").pop()!] =
+            props.document.components.schemas[next.$ref.split("/").pop()!];
+      },
+    });
+  for (const op of props.includes) {
+    if (op.requestBody) visit(op.requestBody.typeName);
+    if (op.responseBody) visit(op.responseBody.typeName);
+  }
+
+  return {
+    histories: [
+      {
+        type: "systemMessage",
+        id: v7(),
+        created_at: new Date().toISOString(),
+        text: AutoBeSystemPromptConstant.INTERFACE_PREREQUISITE,
+      },
+      ...props.preliminary.getHistories(),
+      {
+        type: "assistantMessage",
+        id: v7(),
+        created_at: new Date().toISOString(),
+        text: StringUtil.trim`
+          ## Target Operations
+
+          Operations requiring prerequisite analysis.
+
+          For each of these operations, analyze if they need any prerequisites
+          from the available operations above. Add prerequisites only when there
+          are genuine dependencies like resource existence checks or state validations.
+
+          \`\`\`json
+          ${JSON.stringify(
+            props.includes.map((op) => {
+              return {
+                ...op,
+                requiredIds: getReferenceIds({
+                  document: props.document,
+                  operation: op,
+                }),
+              };
+            }),
+          )}
+          \`\`\`
+
+          ### Domain Schemas
+
+          Schema definitions for the target operations.
+
+          \`\`\`json
+          ${JSON.stringify(domainSchemas)}
+          \`\`\`
+        `,
+      },
+    ],
+    userMessage: "Analyze and add operation prerequisites please",
+  };
+};

package/src/orchestrate/interface/histories/transformInterfaceSchemaHistory.ts

@@ -0,0 +1,105 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+import { v7 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
+import { AutoBePreliminaryController } from "../../common/AutoBePreliminaryController";
+
+export const transformInterfaceSchemaHistory = (props: {
+  operations: AutoBeOpenApi.IOperation[];
+  typeNames: string[];
+  preliminary: AutoBePreliminaryController<
+    "analysisFiles" | "prismaSchemas" | "interfaceOperations"
+  >;
+  instruction: string;
+  already: string[];
+  remained: Set<string>;
+}): IAutoBeOrchestrateHistory => {
+  const schemas: Set<string> = new Set();
+  for (const op of props.operations) {
+    if (op.requestBody) schemas.add(op.requestBody.typeName);
+    if (op.responseBody) schemas.add(op.responseBody.typeName);
+  }
+  return {
+    histories: [
+      {
+        type: "systemMessage",
+        id: v7(),
+        created_at: new Date().toISOString(),
+        text: AutoBeSystemPromptConstant.INTERFACE_SCHEMA,
+      },
+      ...props.preliminary.getHistories(),
+      {
+        type: "assistantMessage",
+        id: v7(),
+        created_at: new Date().toISOString(),
+        text: StringUtil.trim`
+        ## API Design Instructions
+
+        The following API-specific instructions were extracted from
+        the user's requirements. These focus on API interface design aspects
+        such as endpoint patterns, request/response formats, DTO schemas,
+        and operation specifications.
+
+        Follow these instructions when creating JSON schema components.
+        Carefully distinguish between:
+        - Suggestions or recommendations (consider these as guidance)
+        - Direct specifications or explicit commands (these must be followed exactly)
+
+        When instructions contain direct specifications or explicit design decisions,
+        follow them precisely even if you believe you have better alternatives.
+
+        ${props.instruction}
+
+        ## Operations (Filtered for Target Schemas)
+
+        Here is the list of API operations that directly use the schemas
+        you need to generate (via requestBody.typeName or responseBody.typeName).
+
+        These are the ONLY operations relevant to your current task - other
+        operations have been filtered out to reduce noise and improve focus:
+
+        \`\`\`json
+        ${JSON.stringify(props.operations)}
+        \`\`\`
+
+        ## Schemas
+
+        Here is the list of request/response bodies' type names from
+        OpenAPI operations.
+
+        Reference them when creating DTO schema components, especially
+        considering the DTO relationships.
+
+        ${Array.from(schemas)
+          .map((k) => `- \`${k}\``)
+          .join("\n")}
+
+      `,
+      },
+    ],
+    userMessage: StringUtil.trim`
+      Make type components please.
+
+      Here is the list of request/response bodies' type names from
+      OpenAPI operations. Make type components of them. If more object
+      types are required during making the components, please make them
+      too.
+
+      ${Array.from(props.remained)
+        .map((k) => `- \`${k}\``)
+        .join("\n")}${
+        props.already.length !== 0
+          ? StringUtil.trim`
+
+            > By the way, here is the list of components schemas what you've
+            > already made. So, you don't need to make them again.
+            >
+            ${props.already.map((k) => `> - \`${k}\``).join("\n")}
+          `
+          : ""
+      }
+    `,
+  };
+};

package/src/orchestrate/interface/histories/transformInterfaceSchemaRenameHistory.ts

@@ -0,0 +1,56 @@
+import { StringUtil } from "@autobe/utils";
+import { v7 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
+
+export const transformInterfaceSchemaRenameHistory = (props: {
+  tableNames: string[];
+  typeNames: string[];
+}): IAutoBeOrchestrateHistory => {
+  return {
+    histories: [
+      {
+        type: "systemMessage",
+        id: v7(),
+        created_at: new Date().toISOString(),
+        text: AutoBeSystemPromptConstant.INTERFACE_SCHEMA_RENAME,
+      },
+      {
+        type: "assistantMessage",
+        id: v7(),
+        created_at: new Date().toISOString(),
+        text: StringUtil.trim`
+          ## Prisma Table Names
+
+          Here is the complete list of table names from the Prisma database schema.
+          Use these as the source of truth for determining correct DTO type names.
+
+          Each table name should be converted to a DTO type name by:
+          1. Converting from snake_case to PascalCase
+          2. Preserving ALL words from the table name
+          3. Adding "I" prefix for interface types
+
+          **Table Names:**
+          ${props.tableNames.map((name) => `- \`${name}\``).join("\n")}
+
+          ## Current DTO Type Names
+
+          Here is the list of existing DTO type names currently in the OpenAPI specification.
+          Analyze these to identify which ones violate the naming rules by omitting
+          intermediate words or service prefixes from their corresponding table names.
+
+          **Current Type Names:**
+          ${props.typeNames.map((name) => `- \`${name}\``).join("\n")}
+
+          ## Your Task
+
+          Compare the table names with the current type names to identify violations.
+          For each type name that incorrectly omits words from its table name,
+          provide a refactoring entry with the correct name that preserves all components.
+        `,
+      },
+    ],
+    userMessage: "Analyze and provide schema type name refactorings please",
+  };
+};