@autobe/agent 0.0.0 → 0.3.6

package/src/orchestrate/interface/orchestrateInterfaceOperations.ts

@@ -0,0 +1,247 @@
+import { IAgenticaController, MicroAgentica } from "@agentica/core";
+import { AutoBeOpenApi } from "@autobe/interface";
+import { ILlmApplication, ILlmSchema, IValidation } from "@samchon/openapi";
+import { HashMap, HashSet, IPointer } from "tstl";
+import typia from "typia";
+
+import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { assertSchemaModel } from "../../context/assertSchemaModel";
+import { divideArray } from "../../utils/divideArray";
+import { OpenApiEndpointComparator } from "./OpenApiEndpointComparator";
+import { transformInterfaceHistories } from "./transformInterfaceHistories";
+
+export async function orchestrateInterfaceOperations<
+  Model extends ILlmSchema.Model,
+>(
+  ctx: AutoBeContext<Model>,
+  endpoints: AutoBeOpenApi.IEndpoint[],
+  capacity: number = 12,
+): Promise<AutoBeOpenApi.IOperation[]> {
+  const matrix: AutoBeOpenApi.IEndpoint[][] = divideArray({
+    array: endpoints,
+    capacity,
+  });
+  let completed: number = 0;
+  const operations: AutoBeOpenApi.IOperation[][] = await Promise.all(
+    matrix.map(async (it) => {
+      const row: AutoBeOpenApi.IOperation[] = await divideAndConquer(
+        ctx,
+        it,
+        3,
+        (count) => {
+          completed += count;
+        },
+      );
+      ctx.dispatch({
+        type: "interfaceOperations",
+        operations: row,
+        completed,
+        total: endpoints.length,
+        step: ctx.state().analyze?.step ?? 0,
+        created_at: new Date().toISOString(),
+      });
+      return row;
+    }),
+  );
+  return operations.flat();
+}
+
+async function divideAndConquer<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  endpoints: AutoBeOpenApi.IEndpoint[],
+  retry: number,
+  progress: (completed: number) => void,
+): Promise<AutoBeOpenApi.IOperation[]> {
+  const remained: HashSet<AutoBeOpenApi.IEndpoint> = new HashSet(
+    endpoints,
+    OpenApiEndpointComparator.hashCode,
+    OpenApiEndpointComparator.equals,
+  );
+  const operations: HashMap<AutoBeOpenApi.IEndpoint, AutoBeOpenApi.IOperation> =
+    new HashMap(
+      OpenApiEndpointComparator.hashCode,
+      OpenApiEndpointComparator.equals,
+    );
+  for (let i: number = 0; i < retry; ++i) {
+    if (remained.empty() === true || operations.size() >= endpoints.length)
+      break;
+    const before: number = operations.size();
+    const newbie: AutoBeOpenApi.IOperation[] = await process(
+      ctx,
+      Array.from(remained),
+    );
+    for (const item of newbie) {
+      operations.set(item, item);
+      remained.erase(item);
+    }
+    if (operations.size() - before !== 0) progress(operations.size() - before);
+  }
+  return operations.toJSON().map((it) => it.second);
+}
+
+async function process<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  endpoints: AutoBeOpenApi.IEndpoint[],
+): Promise<AutoBeOpenApi.IOperation[]> {
+  const pointer: IPointer<AutoBeOpenApi.IOperation[] | null> = {
+    value: null,
+  };
+  const agentica: MicroAgentica<Model> = new MicroAgentica({
+    model: ctx.model,
+    vendor: ctx.vendor,
+    config: {
+      ...(ctx.config ?? {}),
+      executor: {
+        describe: null,
+      },
+    },
+    histories: transformInterfaceHistories(
+      ctx.state(),
+      AutoBeSystemPromptConstant.INTERFACE_ENDPOINT,
+    ),
+    tokenUsage: ctx.usage(),
+    controllers: [
+      createApplication({
+        model: ctx.model,
+        build: async (endpoints) => {
+          pointer.value = endpoints;
+        },
+        pointer,
+      }),
+    ],
+  });
+  agentica.on("request", async (event) => {
+    event.body.tool_choice = "required";
+  });
+  await agentica.conversate(
+    [
+      "Make API operations for below endpoints:",
+      "",
+      "```json",
+      JSON.stringify(Array.from(endpoints), null, 2),
+      "```",
+    ].join("\n"),
+  );
+  if (pointer.value === null) throw new Error("Failed to create operations."); // never be happened
+  return pointer.value;
+}
+
+function createApplication<Model extends ILlmSchema.Model>(props: {
+  model: Model;
+  build: (operations: AutoBeOpenApi.IOperation[]) => Promise<void>;
+  pointer: IPointer<AutoBeOpenApi.IOperation[] | null>;
+}): IAgenticaController.IClass<Model> {
+  assertSchemaModel(props.model);
+
+  const application: ILlmApplication<Model> = collection[
+    props.model
+  ] as unknown as ILlmApplication<Model>;
+  application.functions[0].validate = (next: unknown): IValidation => {
+    const result: IValidation<IMakeOperationProps> =
+      typia.validate<IMakeOperationProps>(next);
+    if (result.success === false) return result;
+    props.pointer.value = result.data.operations;
+
+    const errors: IValidation.IError[] = [];
+    result.data.operations.forEach((op, i) => {
+      if (op.method === "get" && op.requestBody !== null)
+        errors.push({
+          path: `operations[${i}].requestBody`,
+          expected:
+            "GET method should not have request body. Change method, or re-design the operation.",
+          value: op.requestBody,
+        });
+    });
+    if (errors.length !== 0)
+      return {
+        success: false,
+        errors,
+        data: next,
+      };
+    return result;
+  };
+  return {
+    protocol: "class",
+    name: "interface",
+    application,
+    execute: {
+      makeOperations: async (next) => {
+        await props.build(next.operations);
+        return {
+          success: true,
+        };
+      },
+    } satisfies IApplication,
+  };
+}
+
+const claude = typia.llm.application<
+  IApplication,
+  "claude",
+  { reference: true }
+>();
+const collection = {
+  chatgpt: typia.llm.application<
+    IApplication,
+    "chatgpt",
+    { reference: true }
+  >(),
+  claude,
+  llama: claude,
+  deepseek: claude,
+  "3.1": claude,
+  "3.0": typia.llm.application<IApplication, "3.0">(),
+};
+
+interface IApplication {
+  /**
+   * Generate detailed API operations from path/method combinations.
+   *
+   * This function creates complete API operations following REST principles and
+   * quality standards. Each generated operation includes specification, path,
+   * method, detailed multi-paragraph description, concise summary, parameters,
+   * and appropriate request/response bodies.
+   *
+   * The function processes as many operations as possible in a single call,
+   * with progress tracking to ensure iterative completion of all required
+   * endpoints.
+   *
+   * @param props Properties containing the operations to generate.
+   */
+  makeOperations(props: IMakeOperationProps): void;
+}
+
+interface IMakeOperationProps {
+  /**
+   * Array of API operations to generate.
+   *
+   * Each operation in this array must include:
+   *
+   * - Specification: Detailed API specification with clear purpose and
+   *   functionality
+   * - Path: Resource-centric URL path (e.g., "/resources/{resourceId}")
+   * - Method: HTTP method (get, post, put, delete, patch)
+   * - Description: Extremely detailed multi-paragraph description referencing
+   *   Prisma schema comments
+   * - Summary: Concise one-sentence summary of the endpoint
+   * - Parameters: Array of all necessary parameters with descriptions and schema
+   *   definitions
+   * - RequestBody: For POST/PUT/PATCH methods, with typeName referencing
+   *   components.schemas
+   * - ResponseBody: With typeName referencing appropriate response type
+   *
+   * All operations must follow strict quality standards:
+   *
+   * 1. Detailed descriptions referencing Prisma schema comments
+   * 2. Accurate parameter definitions matching path parameters
+   * 3. Appropriate request/response body type references
+   * 4. Consistent patterns for CRUD operations
+   *
+   * For list retrievals (typically PATCH), include pagination, search, and
+   * sorting. For detail retrieval (GET), return a single resource. For creation
+   * (POST), use .ICreate request body. For modification (PUT), use .IUpdate
+   * request body.
+   */
+  operations: AutoBeOpenApi.IOperation[];
+}

package/src/orchestrate/interface/transformInterfaceHistories.ts

@@ -0,0 +1,98 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+
+import { AutoBeState } from "../../context/AutoBeState";
+
+export const transformInterfaceHistories = (
+  state: AutoBeState,
+  systemMessage: string,
+): Array<
+  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+> => {
+  if (state.analyze === null)
+    return [
+      {
+        type: "systemMessage",
+        text: [
+          "Requirement analysis is not yet completed.",
+          "Don't call the any tool function,",
+          "but say to process the requirement analysis.",
+        ].join(" "),
+      },
+    ];
+  else if (state.prisma === null)
+    return [
+      {
+        type: "systemMessage",
+        text: [
+          "Prisma DB schema generation is not yet completed.",
+          "Don't call the any tool function,",
+          "but say to process the Prisma DB schema generation.",
+        ].join(" "),
+      },
+    ];
+  else if (state.analyze.step !== state.prisma.step)
+    return [
+      {
+        type: "systemMessage",
+        text: [
+          "Prisma DB schema generation has not been updated",
+          "for the latest requirement analysis.",
+          "Don't call the any tool function,",
+          "but say to re-process the Prisma DB schema generation.",
+        ].join(" "),
+      },
+    ];
+  else if (state.prisma.result.type !== "success")
+    return [
+      {
+        type: "systemMessage",
+        text: [
+          "Prisma DB schema generation has not been updated",
+          "for the latest requirement analysis.",
+          "Don't call the any tool function,",
+          "but say to re-process the Prisma DB schema generation.",
+        ].join(" "),
+      },
+    ];
+  return [
+    {
+      type: "systemMessage",
+      text: systemMessage,
+    },
+    {
+      type: "assistantMessage",
+      text: [
+        "Requirement analysis and Prisma DB schema generation are ready.",
+        "",
+        "Call the provided tool function to generate the OpenAPI document",
+        "referencing below requirement analysis and Prisma DB schema.",
+        "",
+        // User Request
+        `## User Request`,
+        "",
+        state.analyze.reason,
+        "",
+        // Requirement Analysis Report
+        `## Requirement Analysis Report`,
+        "",
+        "```json",
+        JSON.stringify(state.analyze.files),
+        "```",
+      ].join("\n"),
+    },
+    {
+      type: "assistantMessage",
+      text: [
+        "## Prisma DB Schema",
+        "```json",
+        JSON.stringify(state.prisma.result.schemas),
+        "```",
+        "",
+        "## Entity Relationship Diagrams",
+        "```json",
+        JSON.stringify(state.prisma.result.diagrams),
+        "```",
+      ].join("\n"),
+    },
+  ];
+};

package/src/orchestrate/orchestrateAnalyze.ts

@@ -1,21 +1,86 @@
-import {
-  AutoBeAnalyzeHistory,
-  AutoBeAssistantMessageHistory,
-} from "@autobe/interface";
-import { ILlmSchema } from "@samchon/openapi";
-
-import { AutoBeContext } from "../context/AutoBeContext";
-import { IAutoBeApplicationProps } from "../context/IAutoBeApplicationProps";
-
-/**
- * @todo Kakasoo
- */
-export const orchestrateAnalyze =
-  <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) =>
-  async (
-    props: IAutoBeApplicationProps,
-  ): Promise<AutoBeAssistantMessageHistory | AutoBeAnalyzeHistory> => {
-    ctx;
-    props;
-    return null!;
-  };
+import {
+  AutoBeAnalyzeHistory,
+  AutoBeAssistantMessageHistory,
+} from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { IPointer } from "tstl";
+import { v4 } from "uuid";
+
+import { AnalyzeAgent } from "../analyze/AnalyzeAgent";
+import { createReviewerAgent } from "../analyze/CreateReviewerAgent";
+import { AutoBeContext } from "../context/AutoBeContext";
+import { IAutoBeApplicationProps } from "../context/IAutoBeApplicationProps";
+
+type Filename = string;
+type FileContent = string;
+
+/** @todo Kakasoo */
+export const orchestrateAnalyze =
+  <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) =>
+  async (
+    props: IAutoBeApplicationProps,
+  ): Promise<AutoBeAssistantMessageHistory | AutoBeAnalyzeHistory> => {
+    const pointer: IPointer<{ files: Record<Filename, FileContent> } | null> = {
+      value: null,
+    };
+
+    const userPlanningRequirements = props.userPlanningRequirements;
+    if (!userPlanningRequirements) {
+      throw new Error(
+        `Unable to prepare a proposal because there is no user requirement`,
+      );
+    }
+
+    const step = ctx.state().analyze?.step ?? 0;
+    const created_at = new Date().toISOString();
+    ctx.dispatch({
+      type: "analyzeStart",
+      reason: userPlanningRequirements,
+      step,
+      created_at,
+    });
+
+    const agent = new AnalyzeAgent(createReviewerAgent, ctx, pointer);
+    const response = await agent.conversate(
+      [
+        `Please write a user requirement report.`,
+        "```json",
+        JSON.stringify(userPlanningRequirements),
+        "```",
+      ].join("\n"),
+    );
+
+    if (pointer.value?.files) {
+      const history: AutoBeAnalyzeHistory = {
+        id: v4(),
+        type: "analyze",
+        reason: userPlanningRequirements,
+        files: pointer.value.files,
+        step,
+        created_at,
+        completed_at: new Date().toISOString(),
+      };
+      ctx.state().analyze = history;
+      ctx.histories().push(history);
+      ctx.dispatch({
+        type: "analyzeComplete",
+        files: pointer.value.files,
+        step,
+        created_at,
+      });
+      return history;
+    }
+    const history: AutoBeAssistantMessageHistory = {
+      id: v4(),
+      type: "assistantMessage",
+      text: response,
+      created_at,
+      completed_at: new Date().toISOString(),
+    };
+    ctx.dispatch({
+      type: "assistantMessage",
+      text: response,
+      created_at,
+    });
+    return history;
+  };

package/src/orchestrate/orchestrateRealize.ts

@@ -1,18 +1,18 @@
-import {
-  AutoBeAssistantMessageHistory,
-  AutoBeRealizeHistory,
-} from "@autobe/interface";
-import { ILlmSchema } from "@samchon/openapi";
-
-import { AutoBeContext } from "../context/AutoBeContext";
-import { IAutoBeApplicationProps } from "../context/IAutoBeApplicationProps";
-
-export const orchestrateRealize =
-  <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) =>
-  async (
-    props: IAutoBeApplicationProps,
-  ): Promise<AutoBeAssistantMessageHistory | AutoBeRealizeHistory> => {
-    ctx;
-    props;
-    return null!;
-  };
+import {
+  AutoBeAssistantMessageHistory,
+  AutoBeRealizeHistory,
+} from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+
+import { AutoBeContext } from "../context/AutoBeContext";
+import { IAutoBeApplicationProps } from "../context/IAutoBeApplicationProps";
+
+export const orchestrateRealize =
+  <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) =>
+  async (
+    props: IAutoBeApplicationProps,
+  ): Promise<AutoBeAssistantMessageHistory | AutoBeRealizeHistory> => {
+    ctx;
+    props;
+    return null!;
+  };

package/src/orchestrate/orchestrateTest.ts

@@ -1,18 +1,18 @@
-import {
-  AutoBeAssistantMessageHistory,
-  AutoBeTestHistory,
-} from "@autobe/interface";
-import { ILlmSchema } from "@samchon/openapi";
-
-import { AutoBeContext } from "../context/AutoBeContext";
-import { IAutoBeApplicationProps } from "../context/IAutoBeApplicationProps";
-
-export const orchestrateTest =
-  <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) =>
-  async (
-    props: IAutoBeApplicationProps,
-  ): Promise<AutoBeAssistantMessageHistory | AutoBeTestHistory> => {
-    ctx;
-    props;
-    return null!;
-  };
+import {
+  AutoBeAssistantMessageHistory,
+  AutoBeTestHistory,
+} from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+
+import { AutoBeContext } from "../context/AutoBeContext";
+import { IAutoBeApplicationProps } from "../context/IAutoBeApplicationProps";
+
+export const orchestrateTest =
+  <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) =>
+  async (
+    props: IAutoBeApplicationProps,
+  ): Promise<AutoBeAssistantMessageHistory | AutoBeTestHistory> => {
+    ctx;
+    props;
+    return null!;
+  };

package/src/orchestrate/prisma/orchestratePrisma.ts

@@ -0,0 +1,117 @@
+import {
+  AutoBeAssistantMessageHistory,
+  AutoBePrismaHistory,
+  IAutoBePrismaCompilerResult,
+} from "@autobe/interface";
+import { AutoBePrismaSchemasEvent } from "@autobe/interface/src/events/AutoBePrismaSchemasEvent";
+import { ILlmSchema } from "@samchon/openapi";
+import { v4 } from "uuid";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
+import { orchestratePrismaCompiler } from "./orchestratePrismaCompiler";
+import { orchestratePrismaComponents } from "./orchestratePrismaComponent";
+import { orchestratePrismaSchemas } from "./orchestratePrismaSchema";
+
+export const orchestratePrisma =
+  <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) =>
+  async (
+    props: IAutoBeApplicationProps,
+  ): Promise<AutoBePrismaHistory | AutoBeAssistantMessageHistory> => {
+    const start: Date = new Date();
+
+    // COMPONENTS
+    const components = await orchestratePrismaComponents(ctx);
+
+    if (components.type === "assistantMessage") {
+      ctx.dispatch(components);
+      ctx.histories().push(components);
+      return components;
+    } else ctx.dispatch(components);
+
+    // SCHEMAS
+    const events: AutoBePrismaSchemasEvent[] = await orchestratePrismaSchemas(
+      ctx,
+      components.components,
+    );
+
+    // COMPILER
+    const files: Record<string, string> = Object.fromEntries(
+      events.map((e) => [e.filename, e.content]),
+    );
+
+    const { description, ...compiledResult } = await orchestratePrismaCompiler(
+      ctx,
+      files,
+    );
+
+    const result = processCompilerResult(compiledResult);
+
+    const history: AutoBePrismaHistory = {
+      type: "prisma",
+      id: v4(),
+      created_at: start.toISOString(),
+      completed_at: new Date().toISOString(),
+      reason: props.reason,
+      description,
+      result: result,
+      step: ctx.state().analyze?.step ?? 0,
+    };
+    ctx.state().prisma = history;
+    ctx.histories().push(history);
+    if (result.type === "success")
+      ctx.dispatch({
+        type: "prismaComplete",
+        schemas: result.schemas,
+        document: result.document,
+        diagrams: result.diagrams,
+        step: ctx.state().analyze?.step ?? 0,
+        created_at: new Date().toISOString(),
+      });
+
+    return history;
+  };
+
+/**
+ * Process the compiler result to generate the main Prisma schema file.
+ *
+ * If the compiler result is a success, the main Prisma schema file will be
+ * generated.
+ *
+ * @param result - The compiler result to process.
+ * @returns The processed compiler result with the main Prisma schema file.
+ */
+function processCompilerResult(
+  result: IAutoBePrismaCompilerResult,
+): IAutoBePrismaCompilerResult {
+  const content = `
+generator client {
+  provider        = "prisma-client-js"
+  previewFeatures = ["postgresqlExtensions", "views"]
+  binaryTargets   = ["native", "linux-musl-arm64-openssl-3.0.x"]
+}
+
+datasource db {
+  provider   = "postgresql"
+  url        = env("DATABASE_URL")
+  extensions = []
+}
+
+generator markdown {
+  provider = "prisma-markdown"
+  output   = "../docs/ERD.md"
+}  
+  `;
+
+  if (result.type === "success") {
+    return {
+      ...result,
+      schemas: {
+        ...result.schemas,
+        "main.prisma": content,
+      },
+    };
+  }
+
+  return result;
+}