@autobe/agent 0.17.1 → 0.19.1

package/src/orchestrate/analyze/writeDocumentUntilReviewPassed.ts

@@ -1,96 +0,0 @@
-import { AutoBeAnalyzeRole } from "@autobe/interface";
-import { ILlmSchema } from "@samchon/openapi";
-
-import { AutoBeContext } from "../../context/AutoBeContext";
-import { IFile } from "./AutoBeAnalyzeFileSystem";
-import {
-  AutoBEAnalyzeFileMap,
-  AutoBeAnalyzePointer,
-} from "./AutoBeAnalyzePointer";
-import { orchestrateAnalyzeReviewer } from "./orchestrateAnalyzeReviewer";
-import { orchestrateAnalyzeWrite } from "./orchestrateAnalyzeWrite";
-
-export async function writeDocumentUntilReviewPassed<
-  Model extends ILlmSchema.Model,
->(
-  ctx: AutoBeContext<Model>,
-  props: {
-    totalFiles: Pick<IFile, "filename" | "reason">[];
-    filename: string;
-    roles: AutoBeAnalyzeRole[];
-    progress: { total: number; completed: number };
-    retry?: number;
-    prevReview?: string;
-  },
-): Promise<AutoBeAnalyzePointer> {
-  const retry = props.retry ?? 3;
-  const pointer: { value: { files: AutoBEAnalyzeFileMap } } = {
-    value: { files: {} },
-  };
-
-  /**
-   * `retry` means the number of times to retry the review. so if `retry` is -1,
-   * it means not execute this logic.
-   */
-  if (retry === -1) {
-    return pointer;
-  }
-
-  let isToolCalled = false;
-  const writer = orchestrateAnalyzeWrite(ctx, {
-    totalFiles: props.totalFiles,
-    roles: props.roles,
-    targetFile: props.filename,
-    review: props.prevReview ?? "",
-    setDocument: (v) => {
-      isToolCalled = true;
-      pointer.value = { files: { ...pointer.value?.files, ...v } };
-    },
-  });
-  await writer.conversate("Write Document.").finally(() => {
-    const tokenUsage = writer.getTokenUsage().aggregate;
-    ctx.usage().record(tokenUsage, ["analyze"]);
-  });
-
-  if (isToolCalled === false) {
-    throw new Error("Failed to write document by unknown reason.");
-  }
-
-  ctx.dispatch({
-    type: "analyzeWrite",
-    files: {
-      ...pointer.value?.files,
-    },
-    total: props.progress.total,
-    completed: ++props.progress.completed,
-    step: ctx.state().analyze?.step ?? 0,
-    created_at: new Date().toISOString(),
-  });
-
-  const reviewResult = await orchestrateAnalyzeReviewer(ctx, pointer.value);
-
-  if (reviewResult.type === "accept") {
-    return pointer;
-  }
-
-  ctx.dispatch({
-    type: "analyzeReview",
-    files: {
-      ...pointer.value.files,
-    },
-    review: reviewResult.value,
-    total: props.progress.total,
-    completed: props.progress.completed,
-    step: ctx.state().analyze?.step ?? 0,
-    created_at: new Date().toISOString(),
-  });
-
-  return await writeDocumentUntilReviewPassed(ctx, {
-    totalFiles: props.totalFiles,
-    filename: props.filename,
-    roles: props.roles,
-    progress: props.progress,
-    retry: retry - 1,
-    prevReview: reviewResult.value,
-  });
-}

package/src/orchestrate/prisma/histories/transformPrismaHistories.ts

@@ -1,59 +0,0 @@
-import { IAgenticaHistoryJson } from "@agentica/core";
-import { v4 } from "uuid";
-
-import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
-import { AutoBeState } from "../../../context/AutoBeState";
-
-export const transformPrismaHistories = (
-  state: AutoBeState,
-): Array<
-  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
-> => {
-  if (state.analyze === null)
-    return [
-      {
-        id: v4(),
-        created_at: new Date().toISOString(),
-        type: "systemMessage",
-        text: [
-          "Requirement analysis is not yet completed.",
-          "Don't call any tool function,",
-          "but say to process the requirement analysis.",
-        ].join(" "),
-      },
-    ];
-  return [
-    {
-      id: v4(),
-      created_at: new Date().toISOString(),
-      type: "systemMessage",
-      text: AutoBeSystemPromptConstant.PRISMA,
-    },
-    {
-      id: v4(),
-      created_at: new Date().toISOString(),
-      type: "assistantMessage",
-      text: AutoBeSystemPromptConstant.PRISMA_EXAMPLE,
-    },
-    {
-      id: v4(),
-      created_at: new Date().toISOString(),
-      type: "assistantMessage",
-      text: [
-        "Here is the requirement analysis report.",
-        "",
-        "Call the provided tool function to generate Prisma DB schema",
-        "referencing below requirement analysis report.",
-        "",
-        "## User Request",
-        state.analyze.reason,
-        "",
-        `## Requirement Analysis Report`,
-        "",
-        "```json",
-        JSON.stringify(state.analyze.files),
-        "```",
-      ].join("\n"),
-    },
-  ];
-};

package/src/orchestrate/realize/RealizePipe.ts

@@ -1,39 +0,0 @@
-import { FAILED } from "./structures/IAutoBeRealizeFailedSymbol";
-
-export function pipe<A, B>(
-  a: A,
-  ab: (a: A) => Promise<B | FAILED>,
-): Promise<B | FAILED>;
-
-export function pipe<A, B, C>(
-  a: A,
-  ab: (a: A) => Promise<B | FAILED>,
-  bc: (b: B) => Promise<C | FAILED>,
-): Promise<C | FAILED>;
-
-export function pipe<A, B, C, D>(
-  a: A,
-  ab: (a: A) => Promise<B | FAILED>,
-  bc: (b: B) => Promise<C | FAILED>,
-  cd: (c: C) => Promise<D | FAILED>,
-): Promise<D | FAILED>;
-
-export function pipe<A, B, C, D, E>(
-  a: A,
-  ab: (a: A) => Promise<B | FAILED>,
-  bc: (b: B) => Promise<C | FAILED>,
-  cd: (c: C) => Promise<D | FAILED>,
-  de: (d: D) => Promise<E | FAILED>,
-): Promise<E | FAILED>;
-
-export function pipe(
-  a: any,
-  ...fns: Array<(arg: any) => Promise<any>>
-): Promise<any> {
-  return fns.reduce((prev, fn) => {
-    return prev.then((result) => {
-      if (result === FAILED) return FAILED;
-      return fn(result);
-    });
-  }, Promise.resolve(a));
-}

package/src/orchestrate/realize/orchestrateRealizeCoder.ts

@@ -1,182 +0,0 @@
-import { IAgenticaController, MicroAgentica } from "@agentica/core";
-import {
-  AutoBeOpenApi,
-  AutoBeRealizeAuthorization,
-  IAutoBeTypeScriptCompileResult,
-} from "@autobe/interface";
-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 { randomBackoffRetry } from "../../utils/backoffRetry";
-import { enforceToolCall } from "../../utils/enforceToolCall";
-import { getTestScenarioArtifacts } from "../test/compile/getTestScenarioArtifacts";
-import { IAutoBeTestScenarioArtifacts } from "../test/structures/IAutoBeTestScenarioArtifacts";
-import { RealizePlannerOutput } from "./orchestrateRealizePlanner";
-import { IAutoBeRealizeCoderApplication } from "./structures/IAutoBeRealizeCoderApplication";
-import { IAutoBeRealizeCompile } from "./structures/IAutoBeRealizeCompile";
-import { FAILED } from "./structures/IAutoBeRealizeFailedSymbol";
-import { transformRealizeCoderHistories } from "./transformRealizeCoderHistories";
-import { RealizeFileSystem } from "./utils/ProviderFileSystem";
-import { replaceImportStatements } from "./utils/replaceImportStatements";
-
-/**
- * Generates a TypeScript function implementation based on the given plan.
- *
- * This function transforms the plan (function name, input/output schema,
- * constraints, and scenarios) into a complete TypeScript function as a string.
- * It is responsible only for producing the code logic, and does not handle
- * imports, exports, or formatting.
- *
- * Import statements are handled separately and will be injected automatically.
- * Any unused imports will be removed by tooling (e.g. eslint).
- *
- * Type annotations should be omitted whenever possible to favor TypeScript's
- * type inference, unless explicit types are critical to correctness.
- *
- * @param ctx - AutoBE execution context
- * @param props - Planning result describing what function to generate
- * @returns The generated function name and TypeScript code
- */
-export const orchestrateRealizeCoder = async <Model extends ILlmSchema.Model>(
-  ctx: AutoBeContext<Model>,
-  operation: AutoBeOpenApi.IOperation,
-  previousCodes: IAutoBeRealizeCompile.Success[],
-  props: RealizePlannerOutput,
-  previous: string | null,
-  total: IAutoBeTypeScriptCompileResult.IDiagnostic[],
-  diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[],
-  authorization?: AutoBeRealizeAuthorization,
-): Promise<IAutoBeRealizeCoderApplication.RealizeCoderOutput | FAILED> => {
-  total;
-
-  const artifacts: IAutoBeTestScenarioArtifacts =
-    await getTestScenarioArtifacts(ctx, {
-      endpoint: {
-        method: operation.method,
-        path: operation.path,
-      },
-      dependencies: [],
-    });
-
-  const pointer: IPointer<Omit<
-    IAutoBeRealizeCoderApplication.RealizeCoderOutput,
-    "filename"
-  > | null> = {
-    value: null,
-  };
-
-  const controller = createApplication({
-    model: ctx.model,
-    build: (props) => {
-      pointer.value = props.output;
-    },
-  });
-
-  const agent = new MicroAgentica({
-    controllers: [controller],
-    model: ctx.model,
-    vendor: ctx.vendor,
-    config: {
-      ...ctx.config,
-      executor: {
-        describe: null,
-      },
-    },
-    histories: transformRealizeCoderHistories(
-      ctx.state(),
-      previousCodes,
-      props,
-      artifacts,
-      previous,
-      diagnostics,
-      authorization,
-    ),
-  });
-  enforceToolCall(agent);
-
-  await randomBackoffRetry(() =>
-    agent.conversate(
-      [
-        `Write complete, production-ready TypeScript code that strictly follows these rules:`,
-        "",
-        `1. Do **not** use the native \`Date\` type anywhere.`,
-        `2. All date or datetime values must be written as \`string & tags.Format<'date-time'>\`.`,
-        `3. UUIDs must be generated using \`v4()\` and typed as \`string & tags.Format<'uuid'>\`.`,
-        `4. Do not use \`as\` for type assertions — resolve types properly.`,
-        `5. All functions must be fully typed with clear parameter and return types.`,
-        `6. Do not skip validations or default values where necessary.`,
-        `7. Follow functional, immutable, and consistent code structure.`,
-        "",
-        `Use \`@nestia/e2e\` test structure if relevant.`,
-      ].join("\n"),
-    ),
-  ).finally(() => {
-    const tokenUsage = agent.getTokenUsage().aggregate;
-    ctx.usage().record(tokenUsage, ["realize"]);
-  });
-
-  if (pointer.value === null) {
-    return FAILED;
-  }
-
-  pointer.value.implementationCode = await replaceImportStatements(ctx)(
-    artifacts,
-    pointer.value.implementationCode,
-    props.decoratorEvent?.payload.name,
-  );
-
-  pointer.value.implementationCode =
-    pointer.value.implementationCode.replaceAll(
-      "typia.tags.assert",
-      "typia.assert",
-    );
-
-  return {
-    ...pointer.value,
-    filename: RealizeFileSystem.providerPath(props.functionName),
-  };
-};
-
-function createApplication<Model extends ILlmSchema.Model>(props: {
-  model: Model;
-  build: (next: IAutoBeRealizeCoderApplication.IProps) => void;
-}): IAgenticaController.IClass<Model> {
-  assertSchemaModel(props.model);
-
-  const application: ILlmApplication<Model> = collection[
-    props.model
-  ] as unknown as ILlmApplication<Model>;
-
-  return {
-    protocol: "class",
-    name: "Write code",
-    application,
-    execute: {
-      programming: (next) => {
-        props.build(next);
-      },
-    } satisfies IAutoBeRealizeCoderApplication,
-  };
-}
-
-const claude = typia.llm.application<
-  IAutoBeRealizeCoderApplication,
-  "claude",
-  {
-    reference: true;
-  }
->();
-const collection = {
-  chatgpt: typia.llm.application<
-    IAutoBeRealizeCoderApplication,
-    "chatgpt",
-    { reference: true }
-  >(),
-  claude,
-  llama: claude,
-  deepseek: claude,
-  "3.1": claude,
-};

package/src/orchestrate/realize/structures/IAutoBeRealizeCompile.ts

@@ -1,70 +0,0 @@
-import {
-  AutoBeOpenApi,
-  IAutoBeTypeScriptCompileResult,
-} from "@autobe/interface";
-import { tags } from "typia";
-
-import { IAutoBeRealizeCoderApplication } from "./IAutoBeRealizeCoderApplication";
-import { FAILED } from "./IAutoBeRealizeFailedSymbol";
-
-export namespace IAutoBeRealizeCompile {
-  export type Result =
-    | IAutoBeRealizeCompile.Success
-    | IAutoBeRealizeCompile.Fail;
-
-  type IBase<T extends "success" | "failed"> = {
-    /**
-     * Indicates whether code generation was attempted. "success" means code was
-     * generated, but compilation may still fail. "failed" means code generation
-     * was not possible (e.g., invalid input).
-     */
-    type: T;
-  };
-
-  export interface Success extends IBase<"success"> {
-    /**
-     * Operation: An object containing the function specification including the
-     * endpoint
-     */
-    operation: AutoBeOpenApi.IOperation;
-
-    /** Result */
-    result: IAutoBeRealizeCoderApplication.RealizeCoderOutput;
-  }
-
-  export interface Fail extends IBase<"failed"> {
-    /**
-     * Operation: An object containing the function specification including the
-     * endpoint
-     */
-    operation: AutoBeOpenApi.IOperation;
-
-    /** Result */
-    result: FAILED;
-  }
-
-  export interface CodeArtifact {
-    result: "failed" | "success";
-    content: string;
-    role?: (string & tags.MinLength<1>) | null;
-    endpoint?: AutoBeOpenApi.IEndpoint;
-    location: string;
-    name?: string;
-  }
-
-  export type FileContentMap = Record<string, CodeArtifact>;
-
-  export interface CompileDiagnostics {
-    /**
-     * Array containing all errors including previous attempts. Includes errors
-     * that have already been resolved. Used to preserve error context and
-     * identify recurring error patterns.
-     */
-    total: IAutoBeTypeScriptCompileResult.IDiagnostic[];
-    /**
-     * Array containing errors from the most recent code compilation. These are
-     * the errors that need to be resolved in the current iteration.
-     */
-    current: IAutoBeTypeScriptCompileResult.IDiagnostic[];
-  }
-}

package/src/orchestrate/realize/structures/IAutoBeRealizeFailedSymbol.ts

@@ -1,2 +0,0 @@
-export const FAILED = Symbol("FAILED");
-export type FAILED = typeof FAILED;

package/src/orchestrate/realize/transformRealizeAuthorization.ts

@@ -1,44 +0,0 @@
-import { IAgenticaHistoryJson } from "@agentica/core";
-import { ILlmSchema } from "@samchon/openapi";
-import { v4 } from "uuid";
-
-import { AutoBeSystemPromptConstant } from "../../constants/AutoBeSystemPromptConstant";
-import { AutoBeContext } from "../../context/AutoBeContext";
-
-export const transformRealizeAuthorizationHistories = (
-  ctx: AutoBeContext<ILlmSchema.Model>,
-  role: string,
-): Array<
-  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
-> => {
-  return [
-    {
-      id: v4(),
-      created_at: new Date().toISOString(),
-      type: "systemMessage",
-      text: AutoBeSystemPromptConstant.REALIZE_AUTHORIZATION,
-    },
-    {
-      id: v4(),
-      created_at: new Date().toISOString(),
-      type: "systemMessage",
-      text: [
-        "## Role",
-        "",
-        role,
-        "",
-        "## Prisma Schema",
-        "",
-        JSON.stringify(ctx.state().prisma?.schemas, null, 2),
-        "",
-        "## Component Naming Convention",
-        "",
-        "Please follow this naming convention for the authorization components:",
-        "",
-        `- Provider Name: ${role}Authorize (e.g. ${role}Authorize)`,
-        `- Decorator Name: ${role.charAt(0).toUpperCase() + role.slice(1)}Auth (e.g. ${role.charAt(0).toUpperCase() + role.slice(1)}Auth)`,
-        `- Payload Name: ${role.charAt(0).toUpperCase() + role.slice(1)}Payload (e.g. ${role.charAt(0).toUpperCase() + role.slice(1)}Payload)`,
-      ].join("\n"),
-    },
-  ];
-};