@autobe/agent 0.10.5 → 0.11.0

package/src/context/AutoBeContext.ts

@@ -3,6 +3,7 @@ import {
   AutoBeEvent,
   AutoBeHistory,
   IAutoBeCompiler,
+  IAutoBeCompilerListener,
   IAutoBeGetFilesOptions,
 } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
@@ -15,7 +16,8 @@ export interface AutoBeContext<Model extends ILlmSchema.Model> {
   model: Model;
   vendor: IAgenticaVendor;
   config: IAutoBeConfig | undefined;
-  compiler: IAutoBeCompiler;
+  compilerListener: IAutoBeCompilerListener;
+  compiler: () => Promise<IAutoBeCompiler>;
   files: (options: IAutoBeGetFilesOptions) => Promise<Record<string, string>>;
   histories: () => AutoBeHistory[];
   state: () => AutoBeState;

package/src/factory/getAutoBeGenerated.ts

@@ -0,0 +1,113 @@
+import {
+  AutoBeHistory,
+  IAutoBeCompiler,
+  IAutoBeGetFilesOptions,
+} from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import typia from "typia";
+
+import { AutoBeContext } from "../context/AutoBeContext";
+import { AutoBeState } from "../context/AutoBeState";
+import { AutoBeTokenUsage } from "../context/AutoBeTokenUsage";
+
+export async function getAutoBeGenerated<Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  histories: AutoBeHistory[],
+  tokenUsage: AutoBeTokenUsage,
+  options?: Partial<IAutoBeGetFilesOptions>,
+): Promise<Record<string, string>> {
+  const state: AutoBeState = ctx.state();
+  const ret: Record<string, string> = {};
+
+  // ANALYZE
+  if (state.analyze === null) return {};
+  Object.assign<Record<string, string>, Record<string, string>>(
+    ret,
+    Object.fromEntries(
+      Object.entries(state.analyze.files).map(([key, value]) => [
+        `docs/analysis/${key.split("/").at(-1)}`,
+        value,
+      ]),
+    ),
+  );
+
+  // PRISMA
+  const compiler: IAutoBeCompiler = await ctx.compiler();
+  if (state.prisma?.step === state.analyze.step) {
+    const schemaFiles: Record<string, string> =
+      (options?.dbms ?? "postgres") === "postgres"
+        ? state.prisma.schemas
+        : await compiler.prisma.write(state.prisma.result.data, options!.dbms!);
+    Object.assign<
+      Record<string, string>,
+      Record<string, string>,
+      Record<string, string>
+    >(
+      ret,
+      Object.fromEntries(
+        Object.entries(schemaFiles).map(([key, value]) => [
+          `prisma/schema/${key.split("/").at(-1)}`,
+          value,
+        ]),
+      ),
+      {
+        "autobe/prisma.json": typia.json.stringify(state.prisma.result.data),
+      },
+    );
+    if (state.prisma.compiled.type === "success")
+      ret["docs/ERD.md"] = state.prisma.compiled.document;
+    else if (state.prisma.compiled.type === "failure")
+      ret["prisma/compile-error-reason.log"] = state.prisma.compiled.reason;
+  }
+
+  // INTERFACE
+  if (state.interface?.step === state.analyze.step) {
+    const files: Record<string, string> = await compiler.interface.write(
+      state.interface.document,
+    );
+    Object.assign<
+      Record<string, string>,
+      Record<string, string>,
+      Record<string, string>
+    >(
+      ret,
+      state.test?.step === state.interface.step
+        ? Object.fromEntries(
+            Object.entries(files).filter(
+              ([key]) => key.startsWith("test/features/") === false,
+            ),
+          )
+        : files,
+      {
+        "autobe/document.json": typia.json.stringify(state.interface.document),
+      },
+    );
+  }
+
+  // TEST
+  if (state.test?.step === state.analyze.step)
+    Object.assign<
+      Record<string, string>,
+      Record<string, string>,
+      Record<string, string>
+    >(
+      ret,
+      Object.fromEntries(state.test.files.map((f) => [f.location, f.content])),
+      await compiler.test.getTemplate(),
+    );
+
+  // REALIZE
+  if (state.realize?.step === state.analyze.step)
+    Object.assign<
+      Record<string, string>,
+      Record<string, string>,
+      Record<string, string>
+    >(ret, state.realize.files, await compiler.realize.getTemplate());
+
+  // LOGGING
+  Object.assign<Record<string, string>, Record<string, string>>(ret, {
+    "autobe/histories.json": typia.json.stringify(histories),
+    "autobe/tokenUsage.json": typia.json.stringify(tokenUsage),
+  });
+  return ret;
+}

package/src/orchestrate/analyze/AutoBeAnalyzeFileSystem.ts

@@ -39,10 +39,9 @@ export interface IAutoBeAnalyzeFileSystem {
    * overwrite it. Generate several markdown files at once. It is recommended
    * that you create multiple files at a time.
    */
-  createOrUpdateFiles(input: ICreateOrUpdateInput): Promise<void>;
-
-  /** Remove markdown file. */
-  removeFile(input: Pick<IFile, "filename">): Promise<void>;
+  createOrUpdateFiles(
+    input: ICreateOrUpdateInput,
+  ): Promise<Record<string, string>>;
 
   /**
    * If you decide that you no longer need any reviews, or if the reviewer
@@ -60,22 +59,15 @@ export class AutoBeAnalyzeFileSystem implements IAutoBeAnalyzeFileSystem {
   constructor(private readonly fileMap: Record<Filename, FileContent> = {}) {}
   async createOrUpdateFiles(input: {
     files: Array<IFile> & tags.MinItems<1>;
-  }): Promise<void> {
+  }): Promise<Record<string, string>> {
     input.files.forEach((file) => {
       this.fileMap[file.filename] = file.markdown;
     });
-  }
 
-  async removeFile(input: Pick<IFile, "filename">): Promise<void> {
-    delete this.fileMap[input.filename];
+    return this.fileMap;
   }
 
   abort(_input: { reason: string }): "OK" {
     return "OK";
   }
-
-  /** @ignore */
-  allFiles(): Record<string, string> {
-    return this.fileMap;
-  }
 }

package/src/orchestrate/analyze/AutoBeAnalyzeRole.ts

@@ -0,0 +1,14 @@
+export interface AutoBeAnalyzeRole {
+  /**
+   * Role name representing user types that can authenticate via API. These are
+   * user roles that can register and login to the service. This will be used as
+   * reference when creating Prisma schema for user authentication.
+   */
+  name: string;
+
+  /**
+   * Description of what this user role can do in the system. Describes the
+   * permissions and capabilities of this authenticated user type.
+   */
+  description: string;
+}

package/src/orchestrate/analyze/orchestrateAnalyze.ts

@@ -1,21 +1,17 @@
-import { IAgenticaController, MicroAgentica } from "@agentica/core";
 import {
   AutoBeAnalyzeHistory,
   AutoBeAssistantMessageHistory,
 } from "@autobe/interface";
-import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
-import typia from "typia";
+import { ILlmSchema } from "@samchon/openapi";
+import { IPointer } from "tstl";
 import { v4 } from "uuid";
 
-import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
-import { assertSchemaModel } from "../../context/assertSchemaModel";
-import { enforceToolCall } from "../../utils/enforceToolCall";
-import { AutoBeAnalyzeAgent } from "./AutoBeAnalyzeAgent";
-import { IFile } from "./AutoBeAnalyzeFileSystem";
 import { AutoBeAnalyzePointer } from "./AutoBeAnalyzePointer";
-import { AutoBeAnalyzeReviewer } from "./AutoBeAnalyzeReviewer";
+import { orchestrateAnalyzeComposer } from "./orchestrateAnalyzeComposer";
+import { IComposeInput } from "./structures/IAutoBeAnalyzeComposerApplication";
+import { writeDocumentUntilReviewPassed } from "./writeDocumentUntilReviewPassed";
 
 /** @todo Kakasoo */
 export const orchestrateAnalyze =
@@ -23,8 +19,8 @@ export const orchestrateAnalyze =
   async (
     props: IAutoBeApplicationProps,
   ): Promise<AutoBeAssistantMessageHistory | AutoBeAnalyzeHistory> => {
-    const step = ctx.state().analyze?.step ?? 0;
-    const created_at = new Date().toISOString();
+    const step: number = ctx.state().analyze?.step ?? 0;
+    const created_at: string = new Date().toISOString();
     ctx.dispatch({
       type: "analyzeStart",
       reason: props.reason,
@@ -32,66 +28,33 @@ export const orchestrateAnalyze =
       created_at,
     });
 
-    const controller = createController<Model>({
-      model: ctx.model,
-      execute: new DeterminingFiles(),
-    });
-
-    const agentica = new MicroAgentica({
-      model: ctx.model,
-      vendor: ctx.vendor,
-      controllers: [controller],
-      config: {
-        locale: ctx.config?.locale,
-        executor: {
-          describe: null,
-        },
-        systemPrompt: {
-          common: () => AutoBeSystemPromptConstant.ANALYZE_PLANNER,
-        },
-      },
-      histories: [
-        ...ctx
-          .histories()
-          .filter(
-            (el) => el.type === "assistantMessage" || el.type === "userMessage",
-          ),
-      ],
-    });
-    enforceToolCall(agentica);
-
+    const pointer: IPointer<IComposeInput | null> = { value: null };
+    const agentica = orchestrateAnalyzeComposer(ctx, pointer);
     const determined = await agentica
-      .conversate("Design a complete list of documents for that document")
+      .conversate(
+        [
+          `Design a complete list of documents and user roles for this project.`,
+          `Define user roles that can authenticate via API and create appropriate documentation files.`,
+          `You must respect the number of documents specified by the user.`,
+        ].join("\n"),
+      )
       .finally(() => {
         const tokenUsage = agentica.getTokenUsage();
         ctx.usage().record(tokenUsage, ["analyze"]);
       });
-
-    const lastMessage = determined[determined.length - 1]!;
-    if (lastMessage.type === "assistantMessage") {
-      const history: AutoBeAssistantMessageHistory = {
+    if (pointer.value === null) {
+      return {
         id: v4(),
+        text: "Failed to analyze your request. please request again.",
         type: "assistantMessage",
-        text: lastMessage.text,
-        created_at,
         completed_at: new Date().toISOString(),
+        created_at: new Date().toISOString(),
       };
-      ctx.dispatch({
-        type: "assistantMessage",
-        text: lastMessage.text,
-        created_at,
-      });
-      return history;
     }
 
-    const described = determined.find((el) => el.type === "describe");
-    const determinedOutput = described?.executes.find(
-      (el) => el.protocol === "class" && typia.is<IDeterminingInput>(el.value),
-    )?.value as IDeterminingInput;
+    const { files: tableOfContents, prefix, roles } = pointer.value;
 
-    const prefix = determinedOutput.prefix;
-    const describedFiles = determinedOutput.files;
-    if (describedFiles.length === 0) {
+    if (tableOfContents.length === 0) {
       const history: AutoBeAssistantMessageHistory = {
         id: v4(),
         type: "assistantMessage",
@@ -108,31 +71,16 @@ export const orchestrateAnalyze =
     }
 
     const pointers = await Promise.all(
-      describedFiles.map(async ({ filename, reason }) => {
-        const pointer: AutoBeAnalyzePointer = { value: null };
-
-        const agent = new AutoBeAnalyzeAgent(
-          AutoBeAnalyzeReviewer,
+      tableOfContents.map(async ({ filename }) => {
+        const pointer: AutoBeAnalyzePointer = { value: { files: {} } };
+        await writeDocumentUntilReviewPassed(
           ctx,
           pointer,
-          describedFiles.map((el) => el.filename),
-        );
-
-        await agent.conversate(
-          [
-            `# Instruction`,
-            `The names of all the files are as follows: ${describedFiles.join(",")}`,
-            "Assume that all files are in the same folder. Also, when pointing to the location of a file, go to the relative path.",
-            "",
-            `Among the various documents, the part you decided to take care of is as follows.: ${filename}`,
-            `Only write this document named '${filename}'.`,
-            "Never write other documents.",
-            "",
-            "The reason why this document needs to be written is as follows.",
-            `- reason: ${reason}`,
-          ].join("\n"),
+          tableOfContents,
+          filename,
+          roles,
+          3,
         );
-
         return pointer;
       }),
     );
@@ -149,6 +97,7 @@ export const orchestrateAnalyze =
         type: "analyze",
         reason: props.reason,
         prefix,
+        roles: roles,
         files: files,
         step,
         created_at,
@@ -180,87 +129,3 @@ export const orchestrateAnalyze =
     });
     return history;
   };
-
-export interface IDeterminingInput {
-  /**
-   * Prefix for file names and all prisma schema files, table, interface, and
-   * variable names. For example, if you were to create a bulletin board
-   * service, the prefix would be bbs. At this time, the name of the document
-   * would be, for example, 00_bbs_table_of_contents, and bbs would have to be
-   * attached to the name of all documents. This value would then be passed to
-   * other agents as well, in the form of bbs_article, bbs_article_snapshot, and
-   * bbs_comments in the table name. Interfaces will likewise be used in
-   * interfaces and tests because they originate from the name of prisma scheme.
-   * Do not use prefixes that are related to the technology stack (e.g., ts_,
-   * api_, react_) or unnatural prefixes that typically wouldn’t appear in table
-   * names or domain models (e.g., zz_, my_, dev_).
-   *
-   * @title Prefix
-   */
-  prefix: string;
-
-  /**
-   * File name must be English. and it must contains the numbering and prefix.
-   *
-   * @title file names and reason to create.
-   */
-  files: Array<Pick<IFile, "filename" | "reason">>;
-}
-
-class DeterminingFiles {
-  /**
-   * Determining the Initial File List.
-   *
-   * Design a list of initial documents that you need to create for that
-   * requirement. The list of documents is determined only by the name of the
-   * file. 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. Simply pass an empty array to `input.files`, which is
-   * the input value for the `determine` tool.
-   *
-   * @param input Prefix and files
-   * @returns
-   */
-  determine(input: IDeterminingInput): IDeterminingInput {
-    return input;
-  }
-}
-
-function createController<Model extends ILlmSchema.Model>(props: {
-  model: Model;
-  execute: DeterminingFiles;
-}): 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: props.execute,
-    execute: {
-      determine: (input) => {
-        return input;
-      },
-    } satisfies DeterminingFiles,
-  };
-}
-
-const claude = typia.llm.application<
-  DeterminingFiles,
-  "claude",
-  { reference: true }
->();
-const collection = {
-  chatgpt: typia.llm.application<
-    DeterminingFiles,
-    "chatgpt",
-    { reference: true }
-  >(),
-  claude,
-  llama: claude,
-  deepseek: claude,
-  "3.1": claude,
-};

package/src/orchestrate/analyze/orchestrateAnalyzeComposer.ts

@@ -0,0 +1,115 @@
+import { IAgenticaController, MicroAgentica } from "@agentica/core";
+import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
+import { 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 { enforceToolCall } from "../../utils/enforceToolCall";
+import {
+  IAutoBeAnalyzeComposerApplication,
+  IComposeInput,
+} from "./structures/IAutoBeAnalyzeComposerApplication";
+
+export const orchestrateAnalyzeComposer = <Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  pointer: IPointer<IComposeInput | null>,
+) => {
+  const controller = createController<Model>({
+    model: ctx.model,
+    execute: new AutoBeAnalyzeComposerApplication(),
+    build: (value: IComposeInput) => {
+      pointer.value = value;
+    },
+  });
+
+  const agent = new MicroAgentica({
+    model: ctx.model,
+    vendor: ctx.vendor,
+    controllers: [controller],
+    config: {
+      locale: ctx.config?.locale,
+      executor: {
+        describe: null,
+      },
+    },
+    histories: [
+      ...ctx
+        .histories()
+        .filter(
+          (h) => h.type === "userMessage" || h.type === "assistantMessage",
+        ),
+      {
+        id: v4(),
+        type: "systemMessage",
+        text: AutoBeSystemPromptConstant.ANALYZE_PLANNER,
+        created_at: new Date().toISOString(),
+      },
+    ],
+  });
+  enforceToolCall(agent);
+  return agent;
+};
+
+class AutoBeAnalyzeComposerApplication
+  implements 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 {
+    return input;
+  }
+}
+
+function createController<Model extends ILlmSchema.Model>(props: {
+  model: Model;
+  execute: AutoBeAnalyzeComposerApplication;
+  build: (input: IComposeInput) => void;
+}): IAgenticaController.IClass<Model> {
+  assertSchemaModel(props.model);
+  const application: ILlmApplication<Model> = collection[
+    props.model
+  ] as unknown as ILlmApplication<Model>;
+  return {
+    protocol: "class",
+    name: "Compose",
+    application,
+    execute: {
+      compose: (input) => {
+        props.build(input);
+        return props.execute.compose(input);
+      },
+    } satisfies IAutoBeAnalyzeComposerApplication,
+  };
+}
+
+const claude = typia.llm.application<
+  AutoBeAnalyzeComposerApplication,
+  "claude",
+  { reference: true }
+>();
+const collection = {
+  chatgpt: typia.llm.application<
+    AutoBeAnalyzeComposerApplication,
+    "chatgpt",
+    { reference: true }
+  >(),
+  claude,
+  llama: claude,
+  deepseek: claude,
+  "3.1": claude,
+};

package/src/orchestrate/analyze/orchestrateAnalyzeReviewer.ts

@@ -0,0 +1,39 @@
+import { MicroAgentica } from "@agentica/core";
+import { ILlmSchema } from "@samchon/openapi";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { randomBackoffStrategy } from "../../utils/backoffRetry";
+import { enforceToolCall } from "../../utils/enforceToolCall";
+import { transformAnalyzeReviewerHistories } from "./transformAnalyzeReviewerHistories";
+
+export const orchestrateAnalyzeReviewer = async <
+  Model extends ILlmSchema.Model,
+>(
+  ctx: AutoBeContext<Model>,
+  input: {
+    /** Total file names */
+    files: Record<string, string>;
+  },
+): Promise<string | null> => {
+  const agent = new MicroAgentica({
+    model: ctx.model,
+    vendor: ctx.vendor,
+    controllers: [],
+    config: {
+      locale: ctx.config?.locale,
+      backoffStrategy: randomBackoffStrategy,
+      executor: {
+        describe: null,
+      },
+    },
+    histories: [...transformAnalyzeReviewerHistories(input)],
+  });
+  enforceToolCall(agent);
+
+  const command = `proceed with the review of these files only.` as const;
+  const histories = await agent.conversate(command).finally(() => {
+    const tokenUsage = agent.getTokenUsage();
+    ctx.usage().record(tokenUsage, ["analyze"]);
+  });
+  return histories.find((h) => h.type === "assistantMessage")?.text ?? null;
+};