@autobe/agent 0.0.0 → 0.3.6

package/src/index.ts

@@ -1,12 +1,13 @@
-export * from "./AutoBeAgent";
-
-export * from "./context/AutoBeTokenUsage";
-
-export * from "./structures/IAutoBeProps";
-export * from "./structures/IAutoBeConfig";
-export * from "./structures/IAutoBeVendor";
-
-/**
- * @internal
- */
-export * as orchestrate from "./orchestrate";
+export * from "./AutoBeAgent";
+
+export * from "./context/AutoBeTokenUsage";
+
+export * from "./structures/IAutoBeProps";
+export * from "./structures/IAutoBeConfig";
+export * from "./structures/IAutoBeVendor";
+
+/** @internal */
+export * as factory from "./factory";
+
+/** @internal */
+export * as orchestrate from "./orchestrate";

package/src/orchestrate/facade/transformFacadeStateMessage.ts

@@ -0,0 +1,58 @@
+import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
+import { AutoBeState } from "../../context/AutoBeState";
+import { StringUtil } from "../../utils/StringUtil";
+
+export function transformFacadeStateMessage(state: AutoBeState): string {
+  const currentState: ICurrentState = getCurrentState(state);
+  return AutoBeSystemPromptConstant.FACADE.replace(
+    "{% STATE %}",
+    StringUtil.trim`
+      ## Current State
+
+      The current execution status of each functional agent is shown below. 
+      Each agent can be in one of three states: "none" (never executed), 
+      "up-to-date" (successfully executed with current output), 
+      or "out-of-date" (previously executed but needs updating due to 
+      changes in earlier stages).
+
+      An agent cannot be executed if any of its prerequisite agents have 
+      a status of "none" or "out-of-date". In such cases, you must complete or 
+      update the earlier stages first. Additionally, re-executing an "up-to-date" 
+      agent will cause all subsequent agents to become "out-of-date", as they 
+      depend on the updated output.
+
+      - analyze: ${currentState.analyze}
+      - prisma: ${currentState.prisma}
+      - interface: ${currentState.interface}
+      - test: ${currentState.test}
+      - realize: ${currentState.realize}
+    `,
+  );
+}
+
+function getCurrentState(state: AutoBeState): ICurrentState {
+  const value = (
+    obj: {
+      step: number;
+    } | null,
+  ) => {
+    if (state.analyze === null || obj === null) return "none";
+    else if (state.analyze.step === obj.step) return "up-to-date";
+    else return "out-of-date";
+  };
+  return {
+    analyze: state.analyze === null ? "none" : "up-to-date",
+    prisma: value(state.prisma),
+    interface: value(state.interface),
+    test: value(state.test),
+    realize: value(state.realize),
+  };
+}
+
+interface ICurrentState {
+  analyze: "up-to-date" | "none";
+  prisma: "up-to-date" | "out-of-date" | "none";
+  interface: "up-to-date" | "out-of-date" | "none";
+  test: "up-to-date" | "out-of-date" | "none";
+  realize: "up-to-date" | "out-of-date" | "none";
+}

package/src/orchestrate/index.ts

@@ -1,5 +1,5 @@
-export { orchestrateAnalyze as analyze } from "./orchestrateAnalyze";
-export { orchestrateInterface as interface } from "./orchestrateInterface";
-export { orchestratePrisma as prisma } from "./orchestratePrisma";
-export { orchestrateTest as test } from "./orchestrateTest";
-export { orchestrateRealize as realize } from "./orchestrateRealize";
+export { orchestrateAnalyze as analyze } from "./orchestrateAnalyze";
+export { orchestrateInterface as interface } from "./interface/orchestrateInterface";
+export { orchestratePrisma as prisma } from "./prisma/orchestratePrisma";
+export { orchestrateTest as test } from "./orchestrateTest";
+export { orchestrateRealize as realize } from "./orchestrateRealize";

package/src/orchestrate/interface/OpenApiEndpointComparator.ts

@@ -0,0 +1,15 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import { hash } from "tstl";
+
+export namespace OpenApiEndpointComparator {
+  export function hashCode(e: AutoBeOpenApi.IEndpoint): number {
+    return hash(e.path, e.method);
+  }
+
+  export function equals(
+    x: AutoBeOpenApi.IEndpoint,
+    y: AutoBeOpenApi.IEndpoint,
+  ): boolean {
+    return x.path === y.path && x.method === y.method;
+  }
+}

package/src/orchestrate/interface/orchestrateInterface.ts

@@ -0,0 +1,66 @@
+import {
+  AutoBeAssistantMessageHistory,
+  AutoBeInterfaceCompleteEvent,
+  AutoBeInterfaceEndpointsEvent,
+  AutoBeInterfaceHistory,
+  AutoBeOpenApi,
+} from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { v4 } from "uuid";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
+import { orchestrateInterfaceComponents } from "./orchestrateInterfaceComponents";
+import { orchestrateInterfaceEndpoints } from "./orchestrateInterfaceEndpoints";
+import { orchestrateInterfaceOperations } from "./orchestrateInterfaceOperations";
+
+export const orchestrateInterface =
+  <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) =>
+  async (
+    props: IAutoBeApplicationProps,
+  ): Promise<AutoBeAssistantMessageHistory | AutoBeInterfaceHistory> => {
+    // ENDPOINTS
+    const start: Date = new Date();
+    const init: AutoBeAssistantMessageHistory | AutoBeInterfaceEndpointsEvent =
+      await orchestrateInterfaceEndpoints(ctx);
+    if (init.type === "assistantMessage") {
+      ctx.dispatch(init);
+      ctx.histories().push(init);
+      return init;
+    } else ctx.dispatch(init);
+
+    // OPERATIONS
+    const operations: AutoBeOpenApi.IOperation[] =
+      await orchestrateInterfaceOperations(ctx, init.endpoints);
+
+    // COMPONENTS
+    const components: AutoBeOpenApi.IComponents =
+      await orchestrateInterfaceComponents(ctx, operations);
+
+    // TYPESCRIPT CODE GENERATION
+    const document: AutoBeOpenApi.IDocument = {
+      operations,
+      components,
+    };
+    const result: AutoBeInterfaceHistory = {
+      type: "interface",
+      id: v4(),
+      document,
+      files: await ctx.compiler.interface(document),
+      reason: props.reason,
+      step: ctx.state().analyze?.step ?? 0,
+      created_at: start.toISOString(),
+      completed_at: new Date().toISOString(),
+    };
+    ctx.state().interface = result;
+    ctx.histories().push(result);
+    ctx.dispatch({
+      type: "interfaceComplete",
+      files: result.files,
+      document: result.document,
+      created_at: start.toISOString(),
+      reason: props.reason,
+      step: ctx.state().analyze?.step ?? 0,
+    } satisfies AutoBeInterfaceCompleteEvent);
+    return result;
+  };

package/src/orchestrate/interface/orchestrateInterfaceComponents.ts

@@ -0,0 +1,324 @@
+import { IAgenticaController, MicroAgentica } from "@agentica/core";
+import { AutoBeOpenApi } from "@autobe/interface";
+import {
+  ILlmApplication,
+  ILlmSchema,
+  IValidation,
+  OpenApiTypeChecker,
+} from "@samchon/openapi";
+import { OpenApiV3_1Emender } from "@samchon/openapi/lib/converters/OpenApiV3_1Emender";
+import { 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 { transformInterfaceHistories } from "./transformInterfaceHistories";
+
+export async function orchestrateInterfaceComponents<
+  Model extends ILlmSchema.Model,
+>(
+  ctx: AutoBeContext<Model>,
+  operations: AutoBeOpenApi.IOperation[],
+  capacity: number = 12,
+): Promise<AutoBeOpenApi.IComponents> {
+  const typeNames: Set<string> = new Set();
+  for (const op of operations) {
+    if (op.requestBody !== null) typeNames.add(op.requestBody.typeName);
+    if (op.responseBody !== null) typeNames.add(op.responseBody.typeName);
+  }
+  const matrix: string[][] = divideArray({
+    array: Array.from(typeNames),
+    capacity,
+  });
+  let progress: number = 0;
+
+  const x: AutoBeOpenApi.IComponents = {
+    schemas: {},
+  };
+  for (const y of await Promise.all(
+    matrix.map(async (it) => {
+      const row: AutoBeOpenApi.IComponents = await divideAndConquer(
+        ctx,
+        operations,
+        it,
+        3,
+        (count) => {
+          progress += count;
+        },
+      );
+      ctx.dispatch({
+        type: "interfaceComponents",
+        components: row,
+        completed: progress,
+        total: typeNames.size,
+        step: ctx.state().analyze?.step ?? 0,
+        created_at: new Date().toISOString(),
+      });
+      return row;
+    }),
+  )) {
+    Object.assign(x.schemas, y.schemas);
+    if (y.authorization) x.authorization = y.authorization;
+  }
+  return x;
+}
+
+async function divideAndConquer<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  operations: AutoBeOpenApi.IOperation[],
+  typeNames: string[],
+  retry: number,
+  progress: (completed: number) => void,
+): Promise<AutoBeOpenApi.IComponents> {
+  const remained: Set<string> = new Set(typeNames);
+  const components: AutoBeOpenApi.IComponents = {
+    schemas: {},
+  };
+  for (let i: number = 0; i < retry; ++i) {
+    if (remained.size === 0) break;
+    const before: number = remained.size;
+    const newbie: AutoBeOpenApi.IComponents = await process(
+      ctx,
+      operations,
+      components,
+      remained,
+    );
+    for (const key of Object.keys(newbie.schemas)) {
+      components.schemas[key] = newbie.schemas[key];
+      remained.delete(key);
+    }
+    if (before - remained.size !== 0) progress(before - remained.size);
+  }
+  return components;
+}
+
+async function process<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  operations: AutoBeOpenApi.IOperation[],
+  oldbie: AutoBeOpenApi.IComponents,
+  remained: Set<string>,
+): Promise<AutoBeOpenApi.IComponents> {
+  const pointer: IPointer<AutoBeOpenApi.IComponents | 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_SCHEMA,
+      ),
+      {
+        type: "assistantMessage",
+        text: [
+          "Here is the OpenAPI operations generated by phase 2.",
+          "",
+          "```json",
+          JSON.stringify(operations),
+          "```",
+        ].join("\n"),
+      },
+    ],
+    tokenUsage: ctx.usage(),
+    controllers: [
+      createApplication({
+        model: ctx.model,
+        build: async (components) => {
+          pointer.value = components;
+        },
+        pointer,
+      }),
+    ],
+  });
+  agentica.on("request", async (event) => {
+    event.body.tool_choice = "required";
+  });
+
+  const already: string[] = Object.keys(oldbie.schemas);
+  await agentica.conversate(
+    [
+      "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(remained).map((k) => `- \`${k}\``),
+      ...(already.length !== 0
+        ? [
+            "",
+            "> By the way, here is the list of components schemas what you've",
+            "> already made. So, you don't need to make them again.",
+            ">",
+            ...already.map((k) => `> - \`${k}\``),
+          ]
+        : []),
+    ].join("\n"),
+  );
+  if (pointer.value === null) {
+    // never be happened
+    throw new Error("Failed to create components.");
+  }
+  return OpenApiV3_1Emender.convertComponents(
+    pointer.value,
+  ) as AutoBeOpenApi.IComponents;
+}
+
+function createApplication<Model extends ILlmSchema.Model>(props: {
+  model: Model;
+  build: (components: AutoBeOpenApi.IComponents) => Promise<void>;
+  pointer: IPointer<AutoBeOpenApi.IComponents | null>;
+}): IAgenticaController.IClass<Model> {
+  assertSchemaModel(props.model);
+
+  const application: ILlmApplication<Model> = collection[
+    props.model
+  ] as unknown as ILlmApplication<Model>;
+  const validate = (next: unknown): IValidation => {
+    const result: IValidation<IMakeComponentsProps> =
+      typia.validate<IMakeComponentsProps>(next);
+    if (result.success === false) return result;
+    props.pointer.value = result.data.components;
+
+    const errors: IValidation.IError[] = [];
+    for (const value of Object.values(result.data.components.schemas)) {
+      OpenApiTypeChecker.visit({
+        components: result.data.components,
+        schema: value,
+        closure: (v) => {
+          if (OpenApiTypeChecker.isReference(v)) {
+            const key: string = v.$ref.split("/").at(-1)!;
+            if (result.data.components.schemas?.[key] === undefined)
+              errors.push({
+                path: `components.schemas.${key}`,
+                expected: "AutoBeOpenApi.IJsonSchemaDescriptive",
+                value: "undefined",
+              });
+          }
+        },
+      });
+    }
+    if (errors.length !== 0)
+      return {
+        success: false,
+        data: result.data,
+        errors,
+      };
+    return result;
+  };
+
+  application.functions[0].validate = validate;
+  return {
+    protocol: "class",
+    name: "interface",
+    application,
+    execute: {
+      makeComponents: async (next) => {
+        await props.build(next.components);
+        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 OpenAPI components containing named schema types.
+   *
+   * This method receives a complete set of schema components and integrates
+   * them into the final OpenAPI specification. It processes all entity schemas,
+   * their variants, and related type definitions to ensure a comprehensive and
+   * consistent API design.
+   *
+   * The provided components should include schemas for all entities identified
+   * in the previous phases of API path/method definition and operation
+   * creation. This ensures that the final OpenAPI document has complete type
+   * coverage for all operations.
+   *
+   * CRITICAL: All schema definitions must follow the established naming
+   * conventions (IEntityName, IEntityName.ICreate, etc.) and must be thoroughly
+   * documented with descriptions that reference the original Prisma schema
+   * comments.
+   *
+   * @param props Properties containing components to generate.
+   */
+  makeComponents(props: IMakeComponentsProps): void;
+}
+
+interface IMakeComponentsProps {
+  /**
+   * Complete set of schema components for the OpenAPI specification.
+   *
+   * This property contains comprehensive type definitions for all entities in
+   * the system. It is the central repository of all named schema types that
+   * will be used throughout the API specification.
+   *
+   * CRITICAL REQUIREMENT: All object types MUST be defined as named types in
+   * the components.schemas section. Inline anonymous object definitions are
+   * strictly prohibited.
+   *
+   * This components object should include:
+   *
+   * - Main entity types (IEntityName)
+   * - Operation-specific variants (.ICreate, .IUpdate, .ISummary, etc.)
+   * - Container types (IPage<T> for pagination)
+   * - Enumeration types
+   *
+   * All schema definitions must include detailed descriptions that reference
+   * the original Prisma schema comments and thoroughly document each property.
+   * Every property that references an object must use a $ref to a named type in
+   * the components.schemas section. This applies to all objects in request
+   * bodies, response bodies, and properties that are objects or arrays of
+   * objects.
+   *
+   * Example structure:
+   *
+   *     components: {
+   *       schemas: {
+   *         IUser: {
+   *           type: "object",
+   *           properties: {
+   *             id: { type: "string", format: "uuid" },
+   *             email: { type: "string", format: "email" },
+   *             profile: { "$ref": "#/components/schemas/IUserProfile" }
+   *           },
+   *           required: ["id", "email"],
+   *           description: "User entity representing system account holders..."
+   *         },
+   *         "IUser.ICreate": { ... },
+   *         // Additional schemas
+   *       }
+   *     }
+   */
+  components: AutoBeOpenApi.IComponents;
+}

package/src/orchestrate/interface/orchestrateInterfaceEndpoints.ts

@@ -0,0 +1,140 @@
+import {
+  AgenticaAssistantMessageHistory,
+  IAgenticaController,
+  MicroAgentica,
+  MicroAgenticaHistory,
+} from "@agentica/core";
+import {
+  AutoBeAssistantMessageHistory,
+  AutoBeInterfaceEndpointsEvent,
+  AutoBeOpenApi,
+} from "@autobe/interface";
+import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
+import { HashSet, IPointer } from "tstl";
+import typia from "typia";
+import { v4 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { assertSchemaModel } from "../../context/assertSchemaModel";
+import { OpenApiEndpointComparator } from "./OpenApiEndpointComparator";
+import { transformInterfaceHistories } from "./transformInterfaceHistories";
+
+export async function orchestrateInterfaceEndpoints<
+  Model extends ILlmSchema.Model,
+>(
+  ctx: AutoBeContext<Model>,
+  content: string = "Make API endpoints for the given assets.",
+): Promise<AutoBeInterfaceEndpointsEvent | AutoBeAssistantMessageHistory> {
+  const start: Date = new Date();
+  const pointer: IPointer<AutoBeOpenApi.IEndpoint[] | 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;
+        },
+      }),
+    ],
+  });
+
+  const histories: MicroAgenticaHistory<Model>[] =
+    await agentica.conversate(content);
+  if (histories.at(-1)?.type === "assistantMessage")
+    return {
+      ...(histories.at(-1)! as AgenticaAssistantMessageHistory),
+      created_at: start.toISOString(),
+      completed_at: new Date().toISOString(),
+      id: v4(),
+    } satisfies AutoBeAssistantMessageHistory;
+  else if (pointer.value === null)
+    throw new Error("Failed to generate endpoints."); // unreachable
+  return {
+    type: "interfaceEndpoints",
+    endpoints: new HashSet(
+      pointer.value,
+      OpenApiEndpointComparator.hashCode,
+      OpenApiEndpointComparator.equals,
+    ).toJSON(),
+    created_at: start.toISOString(),
+    step: ctx.state().analyze?.step ?? 0,
+  } satisfies AutoBeInterfaceEndpointsEvent;
+}
+
+function createApplication<Model extends ILlmSchema.Model>(props: {
+  model: Model;
+  build: (endpoints: AutoBeOpenApi.IEndpoint[]) => Promise<void>;
+}): IAgenticaController.IClass<Model> {
+  assertSchemaModel(props.model);
+
+  const application: ILlmApplication<Model> = collection[
+    props.model
+  ] as unknown as ILlmApplication<Model>;
+  return {
+    protocol: "class",
+    name: "interface",
+    application,
+    execute: {
+      makeEndpoints: async (next) => {
+        await props.build(next.endpoints);
+        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 {
+  /**
+   * Create Restful API endpoints.
+   *
+   * Create Restful API endpoints referencing the given documents; requirement
+   * analysis documents, and Prisma schema files with ERD descriptions. The API
+   * endpoints must cover every requirements and every entities in the ERD.
+   *
+   * Also, each combination of {@link AutoBeOpenApi.IEndpoint.path} and
+   * {@link AutoBeOpenApi.IEndpoint.method} must be unique to avoid duplicates.
+   * Please don't make any duplicates.
+   *
+   * @param props Properties containing the endpoints
+   */
+  makeEndpoints(props: {
+    /** List of endpoints to generate. */
+    endpoints: AutoBeOpenApi.IEndpoint[];
+  }): void;
+}