@autobe/agent 0.28.1 → 0.29.0

package/src/orchestrate/common/orchestratePreliminary.ts

@@ -0,0 +1,361 @@
+import { AgenticaExecuteHistory, MicroAgenticaHistory } from "@agentica/core";
+import {
+  AutoBeEventSource,
+  AutoBeOpenApi,
+  AutoBePreliminaryKind,
+  AutoBePrisma,
+} from "@autobe/interface";
+import { AutoBeAnalyzeFile } from "@autobe/interface/src/histories/contents/AutoBeAnalyzeFile";
+import { ILlmSchema, OpenApiTypeChecker } from "@samchon/openapi";
+import typia from "typia";
+import { v7 } from "uuid";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { AutoBePreliminaryController } from "./AutoBePreliminaryController";
+import { IAutoBePreliminaryRequest } from "./structures/AutoBePreliminaryRequest";
+import { IAutoBePreliminaryCollection } from "./structures/IAutoBePreliminaryCollection";
+
+export const orchestratePreliminary = async <
+  Model extends ILlmSchema.Model,
+  Kind extends AutoBePreliminaryKind,
+>(
+  ctx: AutoBeContext<Model>,
+  props: {
+    source_id: string;
+    source: Exclude<AutoBeEventSource, "facade" | "preliminary">;
+    histories: MicroAgenticaHistory<Model>[];
+    preliminary: AutoBePreliminaryController<Kind>;
+    trial: number;
+  },
+): Promise<void> => {
+  const executes: AgenticaExecuteHistory<Model>[] = props.histories.filter(
+    (h) => h.type === "execute",
+  );
+  if (executes.length === 0) throw new Error("Failed to function calling");
+  for (const exec of executes) {
+    // ANALYSIS
+    if (isAnalysisFiles(props.preliminary, exec.arguments)) {
+      const pa: AutoBePreliminaryController<"analysisFiles"> =
+        props.preliminary;
+      orchestrateAnalyzeFiles(ctx, {
+        source: props.source,
+        source_id: props.source_id,
+        trial: props.trial,
+        all: pa.getAll().analysisFiles,
+        local: pa.getLocal().analysisFiles,
+        arguments: exec.arguments,
+      });
+    }
+    // PRISMA SCHEMAS
+    else if (isPrismaSchemas(props.preliminary, exec.arguments)) {
+      const pp: AutoBePreliminaryController<"prismaSchemas"> =
+        props.preliminary;
+      orchestratePrismaSchemas(ctx, {
+        source: props.source,
+        source_id: props.source_id,
+        trial: props.trial,
+        all: pp.getAll().prismaSchemas,
+        local: pp.getLocal().prismaSchemas,
+        arguments: exec.arguments,
+      });
+    }
+    // INTERFACE OPERATIONS
+    else if (isInterfaceOperations(props.preliminary, exec.arguments)) {
+      const pi: AutoBePreliminaryController<
+        "interfaceOperations" | "interfaceSchemas"
+      > = props.preliminary;
+      orchestrateInterfaceOperations(ctx, {
+        source: props.source,
+        source_id: props.source_id,
+        trial: props.trial,
+        all: {
+          operations: pi.getAll().interfaceOperations,
+          schemas: pi.getAll().interfaceSchemas,
+        },
+        local: {
+          operations: pi.getLocal().interfaceOperations,
+          schemas: pi.getLocal().interfaceSchemas,
+        },
+        arguments: exec.arguments,
+      });
+    }
+    // INTERFACE SCHEMAS
+    else if (isInterfaceSchemas(props.preliminary, exec.arguments)) {
+      const ps: AutoBePreliminaryController<"interfaceSchemas"> =
+        props.preliminary;
+      orchestrateInterfaceSchemas(ctx, {
+        source: props.source,
+        source_id: props.source_id,
+        trial: props.trial,
+        all: ps.getAll().interfaceSchemas,
+        local: ps.getLocal().interfaceSchemas,
+        arguments: exec.arguments,
+      });
+    }
+  }
+};
+
+/* -----------------------------------------------------------
+  TYPE CHECKERS
+----------------------------------------------------------- */
+const isAnalysisFiles = (
+  preliminary: AutoBePreliminaryController<any>,
+  input: unknown,
+): preliminary is AutoBePreliminaryController<"analysisFiles"> =>
+  typia.is<IAutoBePreliminaryRequest<"analysisFiles">>(input) &&
+  preliminary.getAll()[
+    typia.misc.literals<
+      Extract<keyof IAutoBePreliminaryCollection, "analysisFiles">
+    >()[0]
+  ] !== undefined;
+
+const isPrismaSchemas = (
+  preliminary: AutoBePreliminaryController<any>,
+  input: unknown,
+): preliminary is AutoBePreliminaryController<"prismaSchemas"> =>
+  typia.is<IAutoBePreliminaryRequest<"prismaSchemas">>(input) &&
+  preliminary.getAll()[
+    typia.misc.literals<
+      Extract<keyof IAutoBePreliminaryCollection, "prismaSchemas">
+    >()[0]
+  ] !== undefined;
+
+const isInterfaceOperations = (
+  preliminary: AutoBePreliminaryController<any>,
+  input: unknown,
+): preliminary is AutoBePreliminaryController<
+  "interfaceOperations" | "interfaceSchemas"
+> =>
+  typia.is<IAutoBePreliminaryRequest<"interfaceOperations">>(input) &&
+  preliminary.getAll()[
+    typia.misc.literals<
+      Extract<keyof IAutoBePreliminaryCollection, "interfaceOperations">
+    >()[0]
+  ] !== undefined;
+
+const isInterfaceSchemas = (
+  preliminary: AutoBePreliminaryController<any>,
+  input: unknown,
+): preliminary is AutoBePreliminaryController<"interfaceSchemas"> =>
+  typia.is<IAutoBePreliminaryRequest<"interfaceSchemas">>(input) &&
+  preliminary.getAll()[
+    typia.misc.literals<
+      Extract<keyof IAutoBePreliminaryCollection, "interfaceSchemas">
+    >()[0]
+  ] !== undefined;
+
+/* -----------------------------------------------------------
+  ORCHESTRATORS
+----------------------------------------------------------- */
+const orchestrateAnalyzeFiles = <Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  props: {
+    source: Exclude<AutoBeEventSource, "facade" | "preliminary">;
+    source_id: string;
+    trial: number;
+    all: AutoBeAnalyzeFile[];
+    local: AutoBeAnalyzeFile[];
+    arguments: unknown;
+  },
+): void => {
+  if (
+    typia.is<IAutoBePreliminaryRequest<"analysisFiles">>(props.arguments) ===
+    false
+  )
+    return; // unreachable
+
+  const existing: string[] = props.local.map((f) => f.filename);
+  for (const filename of props.arguments.request.fileNames) {
+    const file: AutoBeAnalyzeFile | undefined = props.all.find(
+      (f) => f.filename === filename,
+    );
+    if (file === undefined) continue;
+    else if (props.local.find((x) => x.filename === filename) === undefined)
+      props.local.push(file);
+  }
+  ctx.dispatch({
+    type: "preliminary",
+    id: v7(),
+    function: "analysisFiles",
+    source: props.source,
+    source_id: props.source_id,
+    existing,
+    requested: props.arguments.request.fileNames,
+    trial: props.trial,
+    created_at: new Date().toISOString(),
+  });
+};
+
+const orchestratePrismaSchemas = <Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  props: {
+    source: Exclude<AutoBeEventSource, "facade" | "preliminary">;
+    source_id: string;
+    trial: number;
+    all: AutoBePrisma.IModel[];
+    local: AutoBePrisma.IModel[];
+    arguments: unknown;
+  },
+): void => {
+  if (
+    typia.is<IAutoBePreliminaryRequest<"prismaSchemas">>(props.arguments) ===
+    false
+  )
+    return; // unreachable
+
+  const existing: string[] = props.local.map((m) => m.name);
+  for (const name of props.arguments.request.schemaNames) {
+    const model: AutoBePrisma.IModel | undefined = props.all.find(
+      (m) => m.name === name,
+    );
+    if (model === undefined) continue;
+    else if (props.local.find((m) => m.name === name) === undefined)
+      props.local.push(model);
+  }
+  ctx.dispatch({
+    type: "preliminary",
+    id: v7(),
+    function: "prismaSchemas",
+    source: props.source,
+    source_id: props.source_id,
+    existing,
+    requested: props.arguments.request.schemaNames,
+    trial: props.trial,
+    created_at: new Date().toISOString(),
+  });
+};
+
+const orchestrateInterfaceOperations = <Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  props: {
+    source: Exclude<AutoBeEventSource, "facade" | "preliminary">;
+    source_id: string;
+    trial: number;
+    all: {
+      operations: AutoBeOpenApi.IOperation[];
+      schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
+    };
+    local: {
+      operations: AutoBeOpenApi.IOperation[];
+      schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
+    };
+    arguments: unknown;
+  },
+): void => {
+  if (
+    typia.is<IAutoBePreliminaryRequest<"interfaceOperations">>(
+      props.arguments,
+    ) === false
+  )
+    return; // unreachable
+
+  const existing: AutoBeOpenApi.IEndpoint[] = props.local.operations.map(
+    (o) => ({
+      method: o.method,
+      path: o.path,
+    }),
+  );
+
+  const typeNames: Set<string> = new Set();
+  for (const endpoint of props.arguments.request.endpoints) {
+    if (
+      props.local.operations.find(
+        (v) => v.method === endpoint.method && v.path === endpoint.path,
+      ) !== undefined
+    )
+      continue; // duplicated
+
+    const operation: AutoBeOpenApi.IOperation | undefined =
+      props.all.operations.find(
+        (v) => v.method === endpoint.method && v.path === endpoint.path,
+      );
+    if (operation === undefined) continue; // not found (???)
+
+    props.local.operations.push(operation);
+    if (operation.requestBody !== null)
+      typeNames.add(operation.requestBody.typeName);
+    if (operation.responseBody !== null)
+      typeNames.add(operation.responseBody.typeName);
+  }
+  ctx.dispatch({
+    type: "preliminary",
+    id: v7(),
+    function: "interfaceOperations",
+    source: props.source,
+    source_id: props.source_id,
+    existing,
+    requested: props.arguments.request.endpoints,
+    trial: props.trial,
+    created_at: new Date().toISOString(),
+  });
+
+  orchestrateInterfaceSchemas(
+    ctx,
+    {
+      source: props.source,
+      source_id: props.source_id,
+      trial: props.trial,
+      all: props.all.schemas,
+      local: props.local.schemas,
+      arguments: {
+        thinking: "interface schemas for detailed schema information",
+        request: {
+          type: "getInterfaceSchemas",
+          typeNames: Array.from(typeNames),
+        },
+      } satisfies IAutoBePreliminaryRequest<"interfaceSchemas">,
+    },
+    false,
+  );
+};
+
+const orchestrateInterfaceSchemas = <Model extends ILlmSchema.Model>(
+  ctx: AutoBeContext<Model>,
+  props: {
+    source: Exclude<AutoBeEventSource, "facade" | "preliminary">;
+    source_id: string;
+    trial: number;
+    all: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
+    local: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
+    arguments: unknown;
+  },
+  dispatch: boolean = true,
+): void => {
+  if (
+    typia.is<IAutoBePreliminaryRequest<"interfaceSchemas">>(props.arguments) ==
+    false
+  )
+    return; // unreachable
+
+  const existing: string[] = Object.keys(props.local);
+
+  const collected: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> = {};
+  for (const key of props.arguments.request.typeNames) {
+    OpenApiTypeChecker.visit({
+      components: {
+        schemas: props.all,
+      },
+      schema: { $ref: `#/components/schemas/${key}` },
+      closure: (next) => {
+        if (OpenApiTypeChecker.isReference(next)) {
+          const last: string = next.$ref.split("/").pop()!;
+          collected[last] = props.all[last];
+        }
+      },
+    });
+  }
+  Object.assign(props.local, collected);
+
+  if (dispatch === true)
+    ctx.dispatch({
+      type: "preliminary",
+      id: v7(),
+      function: "interfaceSchemas",
+      source: props.source,
+      source_id: props.source_id,
+      existing,
+      requested: props.arguments.request.typeNames,
+      trial: props.trial,
+      created_at: new Date().toISOString(),
+    });
+};

package/src/orchestrate/common/structures/AutoBePreliminaryRequest.ts

@@ -0,0 +1,18 @@
+import { AutoBePreliminaryKind } from "@autobe/interface";
+
+import { IAutoBePreliminaryGetAnalysisFiles } from "./IAutoBePreliminaryGetAnalysisFiles";
+import { IAutoBePreliminaryGetInterfaceOperations } from "./IAutoBePreliminaryGetInterfaceOperations";
+import { IAutoBePreliminaryGetInterfaceSchemas } from "./IAutoBePreliminaryGetInterfaceSchemas";
+import { IAutoBePreliminaryGetPrismaSchemas } from "./IAutoBePreliminaryGetPrismaSchemas";
+
+export interface IAutoBePreliminaryRequest<Kind extends AutoBePreliminaryKind> {
+  thinking: string;
+  request: Mapper[Kind];
+}
+
+type Mapper = {
+  analysisFiles: IAutoBePreliminaryGetAnalysisFiles;
+  prismaSchemas: IAutoBePreliminaryGetPrismaSchemas;
+  interfaceOperations: IAutoBePreliminaryGetInterfaceOperations;
+  interfaceSchemas: IAutoBePreliminaryGetInterfaceSchemas;
+};

package/src/orchestrate/common/structures/IAutoBeCommonCorrectCastingApplication.ts

@@ -20,10 +20,7 @@ export interface IAutoBeCommonCorrectCastingApplication {
    * - **Optional chaining results**: Uses `=== true` or `??` operators
    * - **"No overlap" errors**: Removes redundant comparisons
    *
-   * @param props - The analysis and correction properties
-   * @param props.think - Analysis of the type casting issue found
-   * @param props.draft - Initial corrected code with type fixes applied
-   * @param props.revise - Review of corrections and final code
+   * @param props The analysis and correction properties
    */
   rewrite(props: IAutoBeCommonCorrectCastingApplication.IProps): void;
 

package/src/orchestrate/common/structures/IAutoBeOrchestrateResult.ts

@@ -0,0 +1,13 @@
+import { MicroAgenticaHistory } from "@agentica/core";
+import {
+  AutoBeFunctionCallingMetric,
+  IAutoBeTokenUsageJson,
+} from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+
+export interface IAutoBeOrchestrateResult<Model extends ILlmSchema.Model, T> {
+  value: T | null;
+  histories: MicroAgenticaHistory<Model>[];
+  tokenUsage: IAutoBeTokenUsageJson.IComponent;
+  metric: AutoBeFunctionCallingMetric;
+}

package/src/orchestrate/common/structures/IAutoBePreliminaryCollection.ts

@@ -0,0 +1,9 @@
+import { AutoBeOpenApi, AutoBePrisma } from "@autobe/interface";
+import { AutoBeAnalyzeFile } from "@autobe/interface/src/histories/contents/AutoBeAnalyzeFile";
+
+export interface IAutoBePreliminaryCollection {
+  analysisFiles: AutoBeAnalyzeFile[];
+  prismaSchemas: AutoBePrisma.IModel[];
+  interfaceOperations: AutoBeOpenApi.IOperation[];
+  interfaceSchemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
+}

package/src/orchestrate/common/structures/IAutoBePreliminaryGetAnalysisFiles.ts

@@ -0,0 +1,29 @@
+import { tags } from "typia";
+
+/**
+ * Request to retrieve requirements analysis files for context.
+ *
+ * This type is used in the preliminary phase to request specific analysis files
+ * that provide business requirements and domain context.
+ */
+export interface IAutoBePreliminaryGetAnalysisFiles {
+  /**
+   * Type discriminator for the request.
+   *
+   * Determines which action to perform: preliminary data retrieval or actual
+   * task execution. Value "getAnalysisFiles" indicates this is a preliminary
+   * data request for analysis files.
+   */
+  type: "getAnalysisFiles";
+
+  /**
+   * List of analysis file names to retrieve.
+   *
+   * File names from the analyze phase containing requirements, use cases, and
+   * business logic documentation.
+   *
+   * CRITICAL: DO NOT request the same file names that you have already
+   * requested in previous calls.
+   */
+  fileNames: string[] & tags.MinItems<1>;
+}

package/src/orchestrate/common/structures/IAutoBePreliminaryGetInterfaceOperations.ts

@@ -0,0 +1,30 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import { tags } from "typia";
+
+/**
+ * Request to retrieve existing interface operations for context.
+ *
+ * This type is used in the preliminary phase to request already-generated API
+ * operations for review, validation, or complementary generation tasks.
+ */
+export interface IAutoBePreliminaryGetInterfaceOperations {
+  /**
+   * Type discriminator for the request.
+   *
+   * Determines which action to perform: preliminary data retrieval or actual
+   * task execution. Value "getInterfaceOperations" indicates this is a
+   * preliminary data request for interface operations.
+   */
+  type: "getInterfaceOperations";
+
+  /**
+   * List of existing API operation endpoints to retrieve.
+   *
+   * Operations that have been generated in previous phases, containing paths,
+   * methods, parameters, and request/response bodies.
+   *
+   * CRITICAL: DO NOT request the same endpoints that you have already requested
+   * in previous calls.
+   */
+  endpoints: AutoBeOpenApi.IEndpoint[] & tags.MinItems<1>;
+}

package/src/orchestrate/common/structures/IAutoBePreliminaryGetInterfaceSchemas.ts

@@ -0,0 +1,29 @@
+import { tags } from "typia";
+
+/**
+ * Request to retrieve OpenAPI schema type definitions for context.
+ *
+ * This type is used in the preliminary phase to request specific schema
+ * definitions from components.schemas for review or complementary generation.
+ */
+export interface IAutoBePreliminaryGetInterfaceSchemas {
+  /**
+   * Type discriminator for the request.
+   *
+   * Determines which action to perform: preliminary data retrieval or actual
+   * task execution. Value "getInterfaceSchemas" indicates this is a preliminary
+   * data request for interface schemas.
+   */
+  type: "getInterfaceSchemas";
+
+  /**
+   * List of schema type names to retrieve.
+   *
+   * Schema names from the OpenAPI components.schemas section (e.g., "IUser",
+   * "IUser.ICreate", "IPost.IUpdate").
+   *
+   * CRITICAL: DO NOT request the same type names that you have already
+   * requested in previous calls.
+   */
+  typeNames: string[] & tags.MinItems<1>;
+}

package/src/orchestrate/common/structures/IAutoBePreliminaryGetPrismaSchemas.ts

@@ -0,0 +1,29 @@
+import { tags } from "typia";
+
+/**
+ * Request to retrieve Prisma database schema definitions for context.
+ *
+ * This type is used in the preliminary phase to request specific Prisma table
+ * schemas needed for generating type-safe API operations.
+ */
+export interface IAutoBePreliminaryGetPrismaSchemas {
+  /**
+   * Type discriminator for the request.
+   *
+   * Determines which action to perform: preliminary data retrieval or actual
+   * task execution. Value "getPrismaSchemas" indicates this is a preliminary
+   * data request for Prisma schemas.
+   */
+  type: "getPrismaSchemas";
+
+  /**
+   * List of Prisma table names to retrieve.
+   *
+   * Table names from the Prisma schema file representing database entities
+   * (e.g., "user", "post", "comment").
+   *
+   * CRITICAL: DO NOT request the same schema names that you have already
+   * requested in previous calls.
+   */
+  schemaNames: string[] & tags.MinItems<1>;
+}

package/src/orchestrate/interface/histories/transformInterfaceAuthorizationHistory.ts

@@ -0,0 +1,77 @@
+import { AutoBeAnalyzeActor, AutoBeAnalyzeHistory } from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+import { v7 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeState } from "../../../context/AutoBeState";
+import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
+import { AutoBePreliminaryController } from "../../common/AutoBePreliminaryController";
+
+export const transformInterfaceAuthorizationHistory = (props: {
+  state: AutoBeState;
+  actor: AutoBeAnalyzeActor;
+  preliminary: AutoBePreliminaryController<"analysisFiles" | "prismaSchemas">;
+  instruction: string;
+}): IAutoBeOrchestrateHistory => {
+  const analyze: AutoBeAnalyzeHistory = props.state.analyze!;
+  return {
+    histories: [
+      {
+        type: "systemMessage",
+        id: v7(),
+        created_at: new Date().toISOString(),
+        text: AutoBeSystemPromptConstant.INTERFACE_AUTHORIZATION,
+      },
+      ...props.preliminary.getHistories(),
+      {
+        type: "systemMessage",
+        id: v7(),
+        created_at: new Date().toISOString(),
+        text: StringUtil.trim`
+          ## Service Prefix
+          - Original: ${analyze.prefix}
+          - PascalCase for DTOs: ${analyze.prefix
+            .split(/[-_]/)
+            .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
+            .join("")}
+          - Expected DTO pattern: I${analyze.prefix
+            .split(/[-_]/)
+            .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
+            .join("")}{EntityName}
+        `,
+      },
+      {
+        type: "assistantMessage",
+        id: v7(),
+        created_at: new Date().toISOString(),
+        text: StringUtil.trim`
+          ## API Design Instructions
+
+          The following API-specific instructions were extracted from
+          the user's requirements. These focus on API interface design aspects
+          such as endpoint patterns, request/response formats, DTO schemas,
+          and operation specifications.
+
+          Follow these instructions when designing authorization operations for ${props.actor.name}.
+          Carefully distinguish between:
+          - Suggestions or recommendations (consider these as guidance)
+          - Direct specifications or explicit commands (these must be followed exactly)
+
+          When instructions contain direct specifications or explicit design decisions,
+          follow them precisely even if you believe you have better alternatives.
+
+          ${props.instruction}
+
+          ## Actor
+
+          You have to make API operations for the given actor:
+
+          \`\`\`json
+          ${JSON.stringify(props.actor)}
+          \`\`\`
+        `,
+      },
+    ],
+    userMessage: `Make authorization operations for ${props.actor.name} actor please`,
+  };
+};

package/src/orchestrate/interface/histories/{transformInterfaceCommonHistories.ts → transformInterfaceCommonHistory.ts}

@@ -3,7 +3,7 @@ import { v7 } from "uuid";
 
 import { AutoBeState } from "../../../context/AutoBeState";
 
-export const transformInterfaceCommonHistories = (
+export const transformInterfaceCommonHistory = (
   state: AutoBeState,
 ): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage