@autobe/agent 0.10.5 → 0.11.0

package/src/orchestrate/analyze/orchestrateAnalyzeWrite.ts

@@ -0,0 +1,106 @@
+import { IAgenticaController, MicroAgentica } from "@agentica/core";
+import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
+import { IPointer } from "tstl";
+import typia from "typia";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { assertSchemaModel } from "../../context/assertSchemaModel";
+import { randomBackoffStrategy } from "../../utils/backoffRetry";
+import { enforceToolCall } from "../../utils/enforceToolCall";
+import {
+  AutoBeAnalyzeFileSystem,
+  IAutoBeAnalyzeFileSystem,
+  IFile,
+} from "./AutoBeAnalyzeFileSystem";
+import {
+  AutoBEAnalyzeFileMap,
+  AutoBeAnalyzePointer,
+} from "./AutoBeAnalyzePointer";
+import { AutoBeAnalyzeRole } from "./AutoBeAnalyzeRole";
+import { transformAnalyzeWriteHistories } from "./transformAnalyzeWriteHistories";
+
+export const orchestrateAnalyzeWrite = <Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  input: {
+    /** Total file names */
+    totalFiles: Pick<IFile, "filename" | "reason">[];
+    targetFile: string;
+    roles: AutoBeAnalyzeRole[];
+    review: string | null;
+  },
+  pointer: AutoBeAnalyzePointer,
+  isAborted: IPointer<boolean>,
+): MicroAgentica<Model> => {
+  const controller = createController<Model>({
+    model: ctx.model,
+    execute: new AutoBeAnalyzeFileSystem({ [input.targetFile]: "" as const }),
+    build: async (files: AutoBEAnalyzeFileMap) => {
+      pointer.value ??= { files: {} };
+      Object.assign(pointer.value.files, files);
+    },
+    abort: () => (isAborted.value = true),
+  });
+
+  const agent = new MicroAgentica({
+    controllers: [controller],
+    model: ctx.model,
+    vendor: ctx.vendor,
+    config: {
+      locale: ctx.config?.locale,
+      backoffStrategy: randomBackoffStrategy,
+      executor: {
+        describe: null,
+      },
+    },
+    histories: [...transformAnalyzeWriteHistories(ctx, input)],
+  });
+  enforceToolCall(agent);
+  return agent;
+};
+
+function createController<Model extends ILlmSchema.Model>(props: {
+  model: Model;
+  execute: AutoBeAnalyzeFileSystem;
+  build: (input: AutoBEAnalyzeFileMap) => void;
+  abort: () => void;
+}): IAgenticaController.IClass<Model> {
+  assertSchemaModel(props.model);
+  const application: ILlmApplication<Model> = collection[
+    props.model
+  ] as unknown as ILlmApplication<Model>;
+  return {
+    protocol: "class",
+    name: "Planning",
+    application,
+    execute: {
+      abort: (input) => {
+        const response = props.execute.abort(input);
+        props.abort();
+
+        return response;
+      },
+      createOrUpdateFiles: async (input) => {
+        const fileMap = await props.execute.createOrUpdateFiles(input);
+        props.build(fileMap);
+        return fileMap;
+      },
+    } satisfies IAutoBeAnalyzeFileSystem,
+  };
+}
+
+const claude = typia.llm.application<
+  AutoBeAnalyzeFileSystem,
+  "claude",
+  { reference: true }
+>();
+const collection = {
+  chatgpt: typia.llm.application<
+    AutoBeAnalyzeFileSystem,
+    "chatgpt",
+    { reference: true }
+  >(),
+  claude,
+  llama: claude,
+  deepseek: claude,
+  "3.1": claude,
+};

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

@@ -0,0 +1,74 @@
+import { IFile } from "../AutoBeAnalyzeFileSystem";
+import { AutoBeAnalyzeRole } from "../AutoBeAnalyzeRole";
+
+export interface IComposeInput {
+  /** Reason for the analysis and composition of the project structure. */
+  reason: string;
+
+  /**
+   * Prefix for file names and all prisma schema files, table, interface, and
+   * variable names.
+   */
+  prefix: string;
+
+  /** Roles to be assigned for the project */
+  roles: AutoBeAnalyzeRole[];
+
+  /**
+   * If the user has requested a specific number of pages, enter that number.
+   * Otherwise, provide an appropriate number of documents needed to meet the
+   * user's requirements. This number must always match the length of the files
+   * property, must be greater than 1, and must include the table of contents.
+   * For example, if the user requests 3 pages, the total should be 4, including
+   * the table of contents.
+   */
+  page: number;
+
+  /**
+   * # Document files to be generated
+   *
+   * File name must be English and it must contain the numbering and prefix.
+   *
+   * These files represent business documentation that may include:
+   *
+   * - Business requirements and functional specifications
+   * - User journey mapping and use case scenarios
+   * - Business rules and workflow definitions
+   * - Service architecture and system design overview
+   * - Data flow and integration requirements
+   * - User roles and permission matrix
+   * - API endpoint specifications and contracts
+   * - Business logic and validation rules
+   *
+   * Generate files based on actual requirements gathered from conversation. Do
+   * not create unnecessary documentation - only generate what is needed to
+   * properly define the business requirements and system specifications.
+   *
+   * # Page Length Rules
+   *
+   * The number of documents must match the user's request, excluding the table
+   * of contents. For example, if the user requests 3 pages, a total of 4
+   * documents should be generated, including the table of contents. If the user
+   * does not specify a number, generate a sufficient number of documents to
+   * adequately support the service.
+   */
+  files: Array<Pick<IFile, "filename" | "reason">>;
+}
+
+export interface IAutoBeAnalyzeComposerApplication {
+  /**
+   * Compose project structure with roles 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
+   * 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`.
+   *
+   * @param input Prefix, roles, and files
+   * @returns
+   */
+  compose(input: IComposeInput): IComposeInput;
+}

package/src/orchestrate/analyze/transformAnalyzeReviewerHistories.ts

@@ -0,0 +1,31 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { v4 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
+
+export const transformAnalyzeReviewerHistories = (input: {
+  /** Total file names */
+  files: Record<string, string>;
+}): Array<
+  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+> => {
+  return [
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "assistantMessage",
+      text: [
+        "Below are all of the files.",
+        "```json",
+        JSON.stringify(input.files),
+        "```",
+      ].join("\n"),
+    },
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.ANALYZE_REVIEWER,
+    },
+  ];
+};

package/src/orchestrate/analyze/transformAnalyzeWriteHistories.ts

@@ -0,0 +1,94 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { ILlmSchema } from "@samchon/openapi";
+import { v4 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { IFile } from "./AutoBeAnalyzeFileSystem";
+import { AutoBeAnalyzeRole } from "./AutoBeAnalyzeRole";
+
+export const transformAnalyzeWriteHistories = <Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  input: {
+    /** Total file names */
+    totalFiles: Pick<IFile, "filename" | "reason">[];
+    targetFile: string;
+    roles: AutoBeAnalyzeRole[];
+    review: string | null;
+  },
+): Array<
+  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+> => {
+  return [
+    ...(input.review !== null
+      ? ([
+          {
+            id: v4(),
+            created_at: new Date().toISOString(),
+            type: "assistantMessage",
+            text: [
+              input.totalFiles.find((el) => el.filename === input.targetFile),
+            ].join("\n"),
+          },
+          {
+            id: v4(),
+            created_at: new Date().toISOString(),
+            type: "assistantMessage",
+            text: [
+              `You previously wrote a piece of content.`,
+              `The following review has been received regarding your writing:`,
+              input.review,
+              `You must revise your content to reflect the feedback in this review.`,
+            ].join(),
+          },
+        ] as const)
+      : []),
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.ANALYZE.replace(
+        "{% User Locale %}",
+        ctx.config?.locale ?? "en-US",
+      ),
+    },
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: [
+        "# Guidelines",
+        "If the user specifies the exact number of pages, please follow it precisely.",
+        AutoBeSystemPromptConstant.ANALYZE_GUIDELINE,
+      ].join("\n"),
+    },
+    {
+      id: v4(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: [
+        `# Instruction`,
+        `The names of all the files are as follows: ${input.totalFiles
+          .map((f) => f.filename)
+          .join(",")}`,
+        "Assume that all files are in the same folder. Also, when pointing to the location of a file, go to the relative path.",
+        "",
+        `The following user roles have been defined for this system:`,
+        ...input.roles.map((role) => `- ${role.name}: ${role.description}`),
+        "These roles will be used for API authentication and should be considered when creating documentation.",
+        "",
+        `Document Length Specification:`,
+        `- You are responsible for writing ONLY ONE document: ${input.targetFile}`,
+        `- Each page should contain approximately 2,000 characters`,
+        `- DO NOT write content for other documents - focus only on ${input.targetFile}`,
+        "",
+        `Among the various documents, the part you decided to take care of is as follows.: ${input.targetFile}`,
+        `Only write this document named '${input.targetFile}'.`,
+        "Never write other documents.",
+        "",
+        "# Reason to write this document",
+        `- ${input.totalFiles.find((el) => el.filename === input.targetFile)?.reason}`,
+      ].join("\n"),
+    },
+  ];
+};

package/src/orchestrate/analyze/writeDocumentUntilReviewPassed.ts

@@ -0,0 +1,66 @@
+import { ILlmSchema } from "@samchon/openapi";
+import { IPointer } from "tstl";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { IFile } from "./AutoBeAnalyzeFileSystem";
+import { AutoBeAnalyzePointer } from "./AutoBeAnalyzePointer";
+import { AutoBeAnalyzeRole } from "./AutoBeAnalyzeRole";
+import { orchestrateAnalyzeReviewer } from "./orchestrateAnalyzeReviewer";
+import { orchestrateAnalyzeWrite } from "./orchestrateAnalyzeWrite";
+
+export async function writeDocumentUntilReviewPassed<
+  Model extends ILlmSchema.Model,
+>(
+  ctx: AutoBeContext<Model>,
+  pointer: AutoBeAnalyzePointer,
+  totalFiles: Pick<IFile, "filename" | "reason">[],
+  filename: string,
+  roles: AutoBeAnalyzeRole[],
+  retry = 3,
+): Promise<AutoBeAnalyzePointer> {
+  const isAborted: IPointer<boolean> = { value: false };
+  let review: string | null = null;
+  for (let i = 0; i < retry; i++) {
+    if (isAborted.value === true) {
+      return pointer;
+    }
+
+    // Write the document until the review is passed.
+    const write = "Write Document OR Abort." as const;
+    const writer = orchestrateAnalyzeWrite(
+      ctx,
+      {
+        totalFiles: totalFiles,
+        roles: roles,
+        targetFile: filename,
+        review,
+      },
+      pointer,
+      isAborted,
+    );
+    await writer.conversate(review ?? write).finally(() => {
+      const tokenUsage = writer.getTokenUsage();
+      ctx.usage().record(tokenUsage, ["analyze"]);
+    });
+    if (pointer.value === null) {
+      throw new Error("Failed to write document by unknown reason.");
+    }
+    ctx.dispatch({
+      type: "analyzeWrite",
+      files: pointer.value.files,
+      step: ctx.state().analyze?.step ?? 0,
+      created_at: new Date().toISOString(),
+    });
+
+    // Do review
+    review = await orchestrateAnalyzeReviewer(ctx, pointer.value);
+    if (review !== null)
+      ctx.dispatch({
+        type: "analyzeReview",
+        review,
+        step: ctx.state().analyze?.step ?? 0,
+        created_at: new Date().toISOString(),
+      });
+  }
+  return pointer;
+}

package/src/orchestrate/interface/orchestrateInterface.ts

@@ -53,7 +53,6 @@ export const orchestrateInterface =
       type: "interface",
       id: v4(),
       document,
-      files: await ctx.compiler.interface.compile(document),
       reason: props.reason,
       step: ctx.state().analyze?.step ?? 0,
       created_at: start.toISOString(),
@@ -63,7 +62,6 @@ export const orchestrateInterface =
     ctx.histories().push(result);
     ctx.dispatch({
       type: "interfaceComplete",
-      files: result.files,
       document: result.document,
       created_at: start.toISOString(),
       reason: props.reason,

package/src/orchestrate/interface/orchestrateInterfaceComponents.ts

@@ -34,6 +34,7 @@ export async function orchestrateInterfaceComponents<
 
   const x: AutoBeOpenApi.IComponents = {
     schemas: {},
+    authorization: ctx.state().analyze?.roles,
   };
   for (const y of await Promise.all(
     matrix.map(async (it) => {
@@ -58,7 +59,6 @@ export async function orchestrateInterfaceComponents<
     }),
   )) {
     Object.assign(x.schemas, y.schemas);
-    if (y.authorization) x.authorization = y.authorization;
   }
   return x;
 }
@@ -132,7 +132,6 @@ async function process<Model extends ILlmSchema.Model>(
           pointer.value ??= {
             schemas: {},
           };
-          pointer.value.authorization ??= components.authorization;
           Object.assign(pointer.value.schemas, components.schemas);
         },
         pointer,
@@ -289,5 +288,5 @@ interface IMakeComponentsProps {
    * }
    * ```
    */
-  components: AutoBeOpenApi.IComponents;
+  components: Omit<AutoBeOpenApi.IComponents, "authorization">;
 }

package/src/orchestrate/interface/orchestrateInterfaceOperations.ts

@@ -88,6 +88,7 @@ async function process<Model extends ILlmSchema.Model>(
   const pointer: IPointer<AutoBeOpenApi.IOperation[] | null> = {
     value: null,
   };
+
   const agentica: MicroAgentica<Model> = new MicroAgentica({
     model: ctx.model,
     vendor: ctx.vendor,
@@ -104,6 +105,7 @@ async function process<Model extends ILlmSchema.Model>(
     controllers: [
       createApplication({
         model: ctx.model,
+        roles: ctx.state().analyze?.roles.map((it) => it.name) ?? null,
         build: (endpoints) => {
           pointer.value ??= [];
           pointer.value.push(...endpoints);
@@ -132,6 +134,7 @@ async function process<Model extends ILlmSchema.Model>(
 
 function createApplication<Model extends ILlmSchema.Model>(props: {
   model: Model;
+  roles: string[] | null;
   build: (operations: AutoBeOpenApi.IOperation[]) => void;
 }): IAgenticaController.IClass<Model> {
   assertSchemaModel(props.model);
@@ -153,6 +156,24 @@ function createApplication<Model extends ILlmSchema.Model>(props: {
             "GET method should not have request body. Change method, or re-design the operation.",
           value: op.requestBody,
         });
+      op.authorizationRoles?.forEach((role, j) => {
+        if (props.roles === null) {
+          op.authorizationRoles = null;
+        }
+        if (props.roles?.find((it) => it === role) === undefined)
+          errors.push({
+            path: `operations[${i}].authorizationRoles[${j}]`,
+            expected: `undefined | ${props.roles?.join(" | ")}`,
+            description: [
+              `Role "${role}" is not defined in the roles list.`,
+              "",
+              "Please select one of them below, or do not define (undefined):  ",
+              "",
+              ...(props.roles ?? []).map((role) => `- ${role}`),
+            ].join("\n"),
+            value: role,
+          });
+      });
     });
     if (errors.length !== 0)
       return {

package/src/orchestrate/prisma/orchestratePrisma.ts

@@ -3,6 +3,7 @@ import {
   AutoBePrismaCompleteEvent,
   AutoBePrismaComponentsEvent,
   AutoBePrismaHistory,
+  IAutoBeCompiler,
   IAutoBePrismaValidation,
 } from "@autobe/interface";
 import { AutoBePrismaSchemasEvent } from "@autobe/interface/src/events/AutoBePrismaSchemasEvent";
@@ -13,7 +14,7 @@ import { AutoBeContext } from "../../context/AutoBeContext";
 import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
 import { orchestratePrismaComponents } from "./orchestratePrismaComponent";
 import { orchestratePrismaCorrect } from "./orchestratePrismaCorrect";
-import { orchestratePrismaSchemas } from "./orchestratePrismaSchema";
+import { orchestratePrismaSchemas } from "./orchestratePrismaSchemas";
 
 export const orchestratePrisma =
   <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) =>
@@ -38,21 +39,28 @@ export const orchestratePrisma =
       return components;
     } else ctx.dispatch(components);
 
-    // SCHEMAS
+    // CONSTRUCT AST DATA
     const events: AutoBePrismaSchemasEvent[] = await orchestratePrismaSchemas(
       ctx,
       components.components,
     );
+
+    // VALIDATE
     const result: IAutoBePrismaValidation = await orchestratePrismaCorrect(
       ctx,
       {
         files: events.map((e) => e.file),
       },
     );
-    const schemas: Record<string, string> = await ctx.compiler.prisma.write(
+
+    // COMPILE
+    const compiler: IAutoBeCompiler = await ctx.compiler();
+    const schemas: Record<string, string> = await compiler.prisma.write(
       result.data,
       "postgres",
     );
+
+    // PROPAGATE
     const history: AutoBePrismaHistory = {
       type: "prisma",
       id: v4(),
@@ -62,14 +70,13 @@ export const orchestratePrisma =
       description: "",
       result: result,
       schemas,
-      compiled: await ctx.compiler.prisma.compile({
+      compiled: await compiler.prisma.compile({
         files: schemas,
       }),
       step: ctx.state().analyze?.step ?? 0,
     };
     ctx.state().prisma = history;
     ctx.histories().push(history);
-
     if (history.result.success === true)
       ctx.dispatch({
         type: "prismaComplete",

package/src/orchestrate/prisma/orchestratePrismaComponent.ts

@@ -4,11 +4,11 @@ import {
   MicroAgentica,
   MicroAgenticaHistory,
 } from "@agentica/core";
-import { AutoBeAssistantMessageHistory } from "@autobe/interface";
+import { AutoBeAssistantMessageHistory, AutoBePrisma } from "@autobe/interface";
 import { AutoBePrismaComponentsEvent } from "@autobe/interface/src/events/AutoBePrismaComponentsEvent";
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
 import { IPointer } from "tstl";
-import typia, { tags } from "typia";
+import typia from "typia";
 import { v4 } from "uuid";
 
 import { AutoBeContext } from "../../context/AutoBeContext";
@@ -25,8 +25,7 @@ export async function orchestratePrismaComponents<
   const pointer: IPointer<IExtractComponentsProps | null> = {
     value: null,
   };
-
-  const prefix = ctx.state().analyze?.prefix ?? null;
+  const prefix: string | null = ctx.state().analyze?.prefix ?? null;
 
   const agentica: MicroAgentica<Model> = new MicroAgentica({
     model: ctx.model,
@@ -178,13 +177,5 @@ interface IExtractComponentsProps {
    * - Keep mapping synchronized with actual schema files
    * - Use consistent naming convention for files
    */
-  components: IComponent[];
-}
-
-interface IComponent {
-  /** Filename of the Prisma schema file. */
-  filename: string & tags.Pattern<"^[a-zA-Z0-9._-]+\\.prisma$">;
-
-  /** List of table names that would be stored in the file. */
-  tables: Array<string & tags.Pattern<"^[a-z][a-z0-9_]*$">>;
+  components: AutoBePrisma.IComponent[];
 }

package/src/orchestrate/prisma/orchestratePrismaCorrect.ts

@@ -1,5 +1,9 @@
 import { IAgenticaController, MicroAgentica } from "@agentica/core";
-import { AutoBePrisma, IAutoBePrismaValidation } from "@autobe/interface";
+import {
+  AutoBePrisma,
+  IAutoBeCompiler,
+  IAutoBePrismaValidation,
+} from "@autobe/interface";
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
 import { IPointer } from "tstl";
 import typia from "typia";
@@ -30,14 +34,15 @@ async function step<Model extends ILlmSchema.Model>(
   application: AutoBePrisma.IApplication,
   life: number,
 ): Promise<IAutoBePrismaValidation> {
+  const compiler: IAutoBeCompiler = await ctx.compiler();
   const result: IAutoBePrismaValidation =
-    await ctx.compiler.prisma.validate(application);
+    await compiler.prisma.validate(application);
   if (result.success)
     return result; // SUCCESS
   else if (life <= 0) return result; // FAILURE
 
   // VALIDATION FAILED
-  const schemas: Record<string, string> = await ctx.compiler.prisma.write(
+  const schemas: Record<string, string> = await compiler.prisma.write(
     application,
     "postgres",
   );
@@ -45,7 +50,7 @@ async function step<Model extends ILlmSchema.Model>(
     type: "prismaValidate",
     result,
     schemas,
-    compiled: await ctx.compiler.prisma.compile({
+    compiled: await compiler.prisma.compile({
       files: schemas,
     }),
     step: ctx.state().analyze?.step ?? 0,