@autobe/agent 0.25.7 → 0.27.0

package/src/orchestrate/analyze/structures/IAutoBeAnalyzeScenarioApplication.ts

@@ -1,20 +1,20 @@
-import { AutoBeAnalyzeRole, CamelCasePattern } from "@autobe/interface";
+import { AutoBeAnalyzeActor, CamelCasePattern } from "@autobe/interface";
 import { AutoBeAnalyzeFile } from "@autobe/interface/src/histories/contents/AutoBeAnalyzeFile";
 import { tags } from "typia";
 
 export interface IAutoBeAnalyzeScenarioApplication {
   /**
-   * Compose project structure with roles and files.
+   * Compose project structure with actors and files.
    *
-   * Design a list of roles and initial documents that you need to create for
-   * that requirement. Roles define team member responsibilities, while files
+   * Design a list of actors and initial documents that you need to create for
+   * that requirement. Actors define user types and their responsibilities, while files
    * define the documentation structure. These are managed separately. If you
    * determine from the conversation that the user's requirements have not been
    * fully gathered, you must stop the analysis and continue collecting the
    * remaining requirements. In this case, you do not need to generate any files
-   * or roles. Simply pass an empty array to `input.files` and `input.roles`.
+   * or actors. Simply pass an empty array to `input.files` and `input.actors`.
    *
-   * @param input Prefix, roles, and files
+   * @param input Prefix, actors, and files
    * @returns
    */
   compose(input: IAutoBeAnalyzeScenarioApplication.IProps): void;
@@ -33,8 +33,8 @@ export namespace IAutoBeAnalyzeScenarioApplication {
      */
     prefix: string & CamelCasePattern;
 
-    /** Roles to be assigned for the project */
-    roles: AutoBeAnalyzeRole[];
+    /** Actors to be assigned for the project */
+    actors: AutoBeAnalyzeActor[];
 
     /**
      * Language for document content. When specified by the user, this takes
@@ -63,7 +63,7 @@ export namespace IAutoBeAnalyzeScenarioApplication {
      * - User journey mapping and use case scenarios
      * - Business rules and workflow definitions
      * - Service overview and business model description
-     * - User roles and permission requirements (described in natural language)
+     * - User actors and permission requirements (described in natural language)
      * - Business logic and validation rules
      * - DO NOT: Include database schemas, ERD, or API specifications
      * - DO: Write all requirements in natural language for clarity

package/src/orchestrate/analyze/structures/IAutoBeAnalyzeWriteApplication.ts

@@ -33,7 +33,7 @@ export namespace IAutoBeAnalyzeWriteApplication {
      * Example plan structure:
      *
      * - Service overview with business model
-     * - User roles and authentication requirements
+     * - User actors and authentication requirements
      * - Functional requirements with EARS format
      * - Non-functional requirements
      * - Business requirements in natural language

package/src/orchestrate/common/histories/transformCommonCorrectCastingHistories.ts

@@ -1,9 +1,9 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
 import { IAutoBeTypeScriptCompileResult } from "@autobe/interface";
-import { StringUtil } from "@autobe/utils";
 import { v7 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { transformPreviousAndLatestCorrectHistories } from "./transformPreviousAndLatestCorrectHistories";
 
 interface IFailure {
   diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[];
@@ -21,23 +21,5 @@ export const transformCommonCorrectCastingHistories = (
     type: "systemMessage",
     text: AutoBeSystemPromptConstant.COMMON_CORRECT_CASTING,
   },
-  ...failures.map(
-    (f, i, array) =>
-      ({
-        id: v7(),
-        created_at: new Date().toISOString(),
-        type: "assistantMessage",
-        text: StringUtil.trim`
-      # ${i === array.length - 1 ? "Latest Failure" : "Previous Failure"}
-      ## Generated TypeScript Code
-      \`\`\`typescript
-      ${f.script}
-      \`\`\`
-      ## Compile Errors
-      \`\`\`json
-      ${JSON.stringify(f.diagnostics)}
-      \`\`\`
-    `,
-      }) satisfies IAgenticaHistoryJson.IAssistantMessage,
-  ),
+  ...transformPreviousAndLatestCorrectHistories(failures),
 ];

package/src/orchestrate/common/histories/transformPreviousAndLatestCorrectHistories.ts

@@ -0,0 +1,65 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { IAutoBeTypeScriptCompileResult } from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+import { v7 } from "uuid";
+
+import { printErrorHints } from "../../realize/utils/printErrorHints";
+
+export const transformPreviousAndLatestCorrectHistories = (
+  array: Array<{
+    script: string;
+    diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[];
+  }>,
+): IAgenticaHistoryJson.IAssistantMessage[] =>
+  array.map((failure, i) => ({
+    id: v7(),
+    type: "assistantMessage",
+    text: StringUtil.trim`
+      ${
+        i === array.length - 1
+          ? "# Latest Failure"
+          : StringUtil.trim`
+            # Previous Failure
+
+            This is the previous failure for your reference.
+
+            Never try to fix this previous failure code, but only
+            focus on the latest failure below. This is provided just
+            to give you context about your past mistakes.
+
+            If same mistake happens again, you must try to not
+            repeat the same mistake. Change your approach to fix
+            the issue.
+          `
+      }
+      
+      ## Original Code
+
+      Here is the previous code you have to review and fix.
+
+      \`\`\`typescript
+      ${failure.script}
+      \`\`\`
+
+      ## Compilation Errors
+
+      Here are the compilation errors found in the code above.
+
+      \`\`\`json
+      ${JSON.stringify(failure.diagnostics)}
+      \`\`\`
+
+      ## Error Annotated Code
+
+      Here is the error annotated code.
+
+      Please refer to the annotation for the location of the error.
+
+      By the way, note that, this code is only for reference purpose.
+      Never fix code from this error annotated code. You must fix
+      the original code above.
+
+      ${printErrorHints(failure.script, failure.diagnostics)}
+    `,
+    created_at: new Date().toISOString(),
+  }));

package/src/orchestrate/common/orchestrateCommonCorrectCasting.ts

@@ -1,4 +1,5 @@
 import {
+  AutoBeFunctionCallingMetric,
   AutoBeRealizeCorrectEvent,
   AutoBeRealizeValidateEvent,
   AutoBeTestCorrectEvent,
@@ -33,6 +34,7 @@ interface IFactoryProps<
     draft: string;
     review: string | undefined;
     final: string | undefined;
+    metric: AutoBeFunctionCallingMetric;
     tokenUsage: IAutoBeTokenUsageJson.IComponent;
   }): CorrectEvent;
   script(event: ValidateEvent): string;
@@ -92,7 +94,7 @@ const correct = async <
   > = {
     value: null,
   };
-  const { tokenUsage } = await ctx.conversate({
+  const { metric, tokenUsage } = await ctx.conversate({
     source: factory.source,
     histories: transformCommonCorrectCastingHistories(
       [...failures, event].map((e) => ({
@@ -115,7 +117,7 @@ const correct = async <
     message: StringUtil.trim`
       Fix the TypeScript casting problems to resolve the compilation error.
 
-      You don't need to explain me anything, but just fix or give it up 
+      You don't need to explain me anything, but just fix or give it up
       immediately without any hesitation, explanation, and questions.
     `,
   });
@@ -129,6 +131,7 @@ const correct = async <
       draft: pointer.value.draft,
       review: pointer.value.revise.review,
       final: pointer.value.revise.final ?? undefined,
+      metric,
       tokenUsage,
     }),
   );

package/src/orchestrate/facade/createAutoBeFacadeController.ts

@@ -0,0 +1,135 @@
+import { IAgenticaController } from "@agentica/core";
+import {
+  AutoBeAnalyzeHistory,
+  AutoBeAssistantMessageEvent,
+  AutoBeAssistantMessageHistory,
+  AutoBeInterfaceHistory,
+  AutoBePrismaHistory,
+  AutoBeRealizeHistory,
+  AutoBeTestHistory,
+} from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
+import typia from "typia";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { assertSchemaModel } from "../../context/assertSchemaModel";
+import { orchestrateAnalyze } from "../analyze/orchestrateAnalyze";
+import { orchestrateInterface } from "../interface/orchestrateInterface";
+import { orchestratePrisma } from "../prisma/orchestratePrisma";
+import { orchestrateRealize } from "../realize/orchestrateRealize";
+import { orchestrateTest } from "../test/orchestrateTest";
+import { IAutoBeFacadeApplication } from "./histories/IAutoBeFacadeApplication";
+
+export const createAutoBeFacadeController = <
+  Model extends ILlmSchema.Model,
+>(props: {
+  model: Model;
+  context: AutoBeContext<Model>;
+}): IAgenticaController.IClass<Model> => {
+  assertSchemaModel(props.model);
+  const application: ILlmApplication<Model> = collection[
+    props.model
+  ] satisfies ILlmApplication<any> as unknown as ILlmApplication<Model>;
+  return {
+    protocol: "class",
+    name: "autobe",
+    application,
+    execute: {
+      analyze: async () => {
+        const history: AutoBeAssistantMessageHistory | AutoBeAnalyzeHistory =
+          await orchestrateAnalyze(props.context);
+        if (history.type === "assistantMessage")
+          return {
+            type: "in-progress",
+            description: StringUtil.trim`
+              Requirements are not yet fully elicited, 
+              therefore additional questions will be made to the user.
+            `,
+          };
+        return {
+          type: "success",
+          description:
+            "Analysis completed successfully, and report has been published.",
+        };
+      },
+      prisma: async (next) => {
+        const history: AutoBeAssistantMessageHistory | AutoBePrismaHistory =
+          await orchestratePrisma(props.context, next);
+        if (history.type === "assistantMessage")
+          return {
+            type: "prerequisites-not-satisfied",
+            description: "Requirement analysis is not yet completed.",
+          };
+        return {
+          type: history.compiled.type,
+          description:
+            history.compiled.type === "success"
+              ? "Prisma schemas have been generated successfully."
+              : history.result.success === false ||
+                  history.compiled.type === "failure"
+                ? "Prisma schemas are generated, but compilation failed."
+                : "Unexpected error occurred while generating Prisma schemas.",
+        };
+      },
+      interface: async (next) => {
+        const history: AutoBeAssistantMessageEvent | AutoBeInterfaceHistory =
+          await orchestrateInterface(props.context)(next);
+        if (history.type === "assistantMessage")
+          return {
+            type: "prerequisites-not-satisfied",
+            description: "Prisma schemas are not yet completed.",
+          };
+        return {
+          type: "success",
+          description: "API interfaces have been designed successfully.",
+        };
+      },
+      test: async (next) => {
+        const history: AutoBeAssistantMessageHistory | AutoBeTestHistory =
+          await orchestrateTest(props.context)(next);
+        if (history.type === "assistantMessage")
+          return {
+            type: "prerequisites-not-satisfied",
+            description: "API interfaces are not yet completed.",
+          };
+        return {
+          type: history.compiled.type,
+          description:
+            history.compiled.type === "success"
+              ? "Test functions have been generated successfully."
+              : history.compiled.type === "failure"
+                ? "Test functions are written, but compilation failed."
+                : "Unexpected error occurred while writing test functions.",
+        };
+      },
+      realize: async (next) => {
+        const history: AutoBeAssistantMessageHistory | AutoBeRealizeHistory =
+          await orchestrateRealize(props.context)(next);
+        if (history.type === "assistantMessage")
+          return {
+            type: "prerequisites-not-satisfied",
+            description: "API interfaces are not yet completed.",
+          };
+        return {
+          type: history.compiled.type,
+          description:
+            history.compiled.type === "success"
+              ? "API implementation codes have been generated successfully."
+              : history.compiled.type === "failure"
+                ? "Implementation codes are composed, but compilation failed."
+                : "Unexpected error occurred while writing implementation codes.",
+        };
+      },
+    } satisfies IAutoBeFacadeApplication,
+  };
+};
+
+const claude = typia.llm.application<IAutoBeFacadeApplication, "claude">();
+const collection = {
+  chatgpt: typia.llm.application<IAutoBeFacadeApplication, "chatgpt">(),
+  claude,
+  llama: claude,
+  deepseek: claude,
+  "3.1": claude,
+};

package/src/orchestrate/facade/{transformFacadeStateMessage.ts → structures/transformFacadeStateMessage.ts}

@@ -1,7 +1,7 @@
 import { StringUtil } from "@autobe/utils";
 
-import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
-import { AutoBeState } from "../../context/AutoBeState";
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeState } from "../../../context/AutoBeState";
 
 export function transformFacadeStateMessage(state: AutoBeState): string {
   const currentState: ICurrentState = getCurrentState(state);

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

@@ -1,5 +1,5 @@
 import { IAgenticaHistoryJson } from "@agentica/core";
-import { AutoBeAnalyzeHistory, AutoBeAnalyzeRole } from "@autobe/interface";
+import { AutoBeAnalyzeActor, AutoBeAnalyzeHistory } from "@autobe/interface";
 import { StringUtil } from "@autobe/utils";
 import { v7 } from "uuid";
 
@@ -9,7 +9,7 @@ import { transformInterfaceAssetHistories } from "./transformInterfaceAssetHisto
 
 export const transformInterfaceAuthorizationsHistories = (props: {
   state: AutoBeState;
-  role: AutoBeAnalyzeRole;
+  actor: AutoBeAnalyzeActor;
   instruction: string;
 }): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
@@ -52,22 +52,22 @@ export const transformInterfaceAuthorizationsHistories = (props: {
         such as endpoint patterns, request/response formats, DTO schemas,
         and operation specifications.
 
-        Follow these instructions when designing authorization operations for ${props.role.name}.
+        Follow these instructions when designing authorization operations for ${props.actor.name}.
         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}
 
-        ## Role
-        
-        You have to make API operations for the given role:
+        ## Actor
+
+        You have to make API operations for the given actor:
 
         \`\`\`json
-        ${JSON.stringify(props.role)}
+        ${JSON.stringify(props.actor)}
         \`\`\`
       `,
     },

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

@@ -24,6 +24,7 @@ export const transformInterfaceEndpointsReviewHistories = (
     type: "assistantMessage",
     text: [
       "Below are endpoints generated by your request.",
+      "",
       "```json",
       JSON.stringify(endpoints),
       "```",

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

@@ -10,22 +10,29 @@ import { transformInterfaceAssetHistories } from "./transformInterfaceAssetHisto
 export const transformInterfaceSchemaHistories = (props: {
   state: AutoBeState;
   operations: AutoBeOpenApi.IOperation[];
+  typeNames: string[];
   instruction: string;
 }): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
-> => [
-  {
-    type: "systemMessage",
-    id: v7(),
-    created_at: new Date().toISOString(),
-    text: AutoBeSystemPromptConstant.INTERFACE_SCHEMA,
-  },
-  ...transformInterfaceAssetHistories(props.state),
-  {
-    type: "assistantMessage",
-    id: v7(),
-    created_at: new Date().toISOString(),
-    text: StringUtil.trim`
+> => {
+  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 [
+    {
+      type: "systemMessage",
+      id: v7(),
+      created_at: new Date().toISOString(),
+      text: AutoBeSystemPromptConstant.INTERFACE_SCHEMA,
+    },
+    ...transformInterfaceAssetHistories(props.state),
+    {
+      type: "assistantMessage",
+      id: v7(),
+      created_at: new Date().toISOString(),
+      text: StringUtil.trim`
       ## API Design Instructions
 
       The following API-specific instructions were extracted from
@@ -33,23 +40,41 @@ export const transformInterfaceSchemaHistories = (props: {
       such as endpoint patterns, request/response formats, DTO schemas,
       and operation specifications.
 
-      Follow these instructions when creating JSON schema components. 
+      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, 
+
+      When instructions contain direct specifications or explicit design decisions,
       follow them precisely even if you believe you have better alternatives.
 
       ${props.instruction}
 
-      ## Operations
+      ## 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).
 
-      Here is the list of API operations you have to implement its types:
+      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")}
+
     `,
-  },
-];
+    },
+  ];
+};

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

@@ -0,0 +1,55 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { StringUtil } from "@autobe/utils";
+import { v7 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+
+export const transformInterfaceSchemaRenameHistories = (props: {
+  tableNames: string[];
+  typeNames: string[];
+}): Array<
+  IAgenticaHistoryJson.ISystemMessage | IAgenticaHistoryJson.IAssistantMessage
+> => {
+  return [
+    {
+      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.
+      `,
+    },
+  ];
+};

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

@@ -0,0 +1,90 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { AutoBeOpenApi } from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+import { v7 } from "uuid";
+
+import { AutoBeState } from "../../../context/AutoBeState";
+import { transformInterfaceAssetHistories } from "./transformInterfaceAssetHistories";
+
+export const transformInterfaceSchemaReviewHistories = (props: {
+  state: AutoBeState;
+  systemPrompt: string;
+  instruction: string;
+  operations: AutoBeOpenApi.IOperation[];
+  everySchemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
+  reviewSchemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
+}): Array<
+  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+> => {
+  return [
+    {
+      type: "systemMessage",
+      id: v7(),
+      created_at: new Date().toISOString(),
+      text: props.systemPrompt,
+    },
+    ...transformInterfaceAssetHistories(props.state),
+    {
+      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
+        relevant to the review task.
+
+        Follow these instructions when reviewing and fixing schemas.
+        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}
+
+        ## Schemas (Complete Set for Reference)
+
+        Here is the COMPLETE set of all schemas in the system for
+        reference context:
+
+        \`\`\`json
+        ${JSON.stringify(props.everySchemas)}
+        \`\`\`
+      `,
+    },
+    {
+      id: v7(),
+      type: "assistantMessage",
+      created_at: new Date().toISOString(),
+      text: StringUtil.trim`
+        ## Schemas Needing Review
+
+        From the complete schema set above, here are the SPECIFIC schemas that need review:
+
+        \`\`\`json
+        ${JSON.stringify(props.reviewSchemas)}
+        \`\`\`
+
+        IMPORTANT: Only these ${Object.keys(props.reviewSchemas).length} schemas
+        need review and potential modification. The other schemas in
+        the full set are provided for reference only.
+
+        ## Operations (Filtered for Target Schemas)
+
+        Here are the API operations that directly use the schemas under review.
+        These operations reference at least one of the target schemas via
+        requestBody.typeName or responseBody.typeName.
+
+        This FILTERED list helps you understand the exact usage context for
+        the schemas you're reviewing:
+
+        \`\`\`json
+        ${JSON.stringify(props.operations)}
+        \`\`\`
+      `,
+    },
+  ];
+};