@autobe/agent 0.30.0-dev.20260315 → 0.30.0

package/src/orchestrate/realize/orchestrateRealizeOperationWrite.ts

@@ -1,262 +1,262 @@
-import {
-  AutoBeEventSource,
-  AutoBeOpenApi,
-  AutoBeProgressEventBase,
-  AutoBeRealizeAuthorization,
-  AutoBeRealizeCollectorFunction,
-  AutoBeRealizeOperationFunction,
-  AutoBeRealizeTransformerFunction,
-  AutoBeRealizeWriteEvent,
-} from "@autobe/interface";
-import { IPointer } from "tstl";
-import typia, { ILlmApplication, ILlmController, IValidation } from "typia";
-import { v7 } from "uuid";
-
-import { AutoBeContext } from "../../context/AutoBeContext";
-import { buildAnalysisContextSections } from "../../utils/RAGRetrieval";
-import { executeCachedBatch } from "../../utils/executeCachedBatch";
-import { forceRetry } from "../../utils/forceRetry";
-import { getEmbedder } from "../../utils/getEmbedder";
-import { validateEmptyCode } from "../../utils/validateEmptyCode";
-import { AutoBePreliminaryController } from "../common/AutoBePreliminaryController";
-import { convertToSectionEntries } from "../common/internal/convertToSectionEntries";
-import { IAnalysisSectionEntry } from "../common/structures/IAnalysisSectionEntry";
-import { transformRealizeOperationWriteHistory } from "./histories/transformRealizeOperationWriteHistory";
-import { AutoBeRealizeOperationProgrammer } from "./programmers/AutoBeRealizeOperationProgrammer";
-import { IAutoBeRealizeOperationWriteApplication } from "./structures/IAutoBeRealizeOperationWriteApplication";
-import { IAutoBeRealizeScenarioResult } from "./structures/IAutoBeRealizeScenarioResult";
-
-export async function orchestrateRealizeOperationWrite(
-  ctx: AutoBeContext,
-  props: {
-    authorizations: AutoBeRealizeAuthorization[];
-    collectors: AutoBeRealizeCollectorFunction[];
-    transformers: AutoBeRealizeTransformerFunction[];
-    progress: AutoBeProgressEventBase;
-  },
-): Promise<AutoBeRealizeOperationFunction[]> {
-  const document: AutoBeOpenApi.IDocument = ctx.state().interface!.document;
-  const scenarios: IAutoBeRealizeScenarioResult[] = document.operations.map(
-    (operation) =>
-      AutoBeRealizeOperationProgrammer.getScenario({
-        authorizations: props.authorizations,
-        operation,
-      }),
-  );
-  return await executeCachedBatch(
-    ctx,
-    scenarios.map(
-      (s) => (promptCacheKey) =>
-        forceRetry(() =>
-          process(ctx, {
-            document,
-            totalAuthorizations: props.authorizations,
-            collectors: props.collectors,
-            transformers: props.transformers,
-            authorization: s.decoratorEvent ?? null,
-            scenario: s,
-            progress: props.progress,
-            promptCacheKey,
-          }),
-        ),
-    ),
-  );
-}
-
-async function process(
-  ctx: AutoBeContext,
-  props: {
-    document: AutoBeOpenApi.IDocument;
-    authorization: AutoBeRealizeAuthorization | null;
-    collectors: AutoBeRealizeCollectorFunction[];
-    totalAuthorizations: AutoBeRealizeAuthorization[];
-    scenario: IAutoBeRealizeScenarioResult;
-    transformers: AutoBeRealizeTransformerFunction[];
-    progress: AutoBeProgressEventBase;
-    promptCacheKey: string;
-  },
-): Promise<AutoBeRealizeOperationFunction> {
-  const allSections: IAnalysisSectionEntry[] = convertToSectionEntries(
-    ctx.state().analyze?.files ?? [],
-  );
-
-  const pathSegments = props.scenario.operation.path
-    .split("/")
-    .filter((p) => p && !p.startsWith(":") && !p.startsWith("{"));
-  const queryText: string = [
-    "operation",
-    "write",
-    props.scenario.operation.method,
-    ...pathSegments,
-    props.scenario.functionName,
-  ].join(" ");
-
-  const ragSections: IAnalysisSectionEntry[] =
-    await buildAnalysisContextSections(
-      getEmbedder(),
-      allSections,
-      queryText,
-      "TOPK",
-      { log: false, logPrefix: "realizeOperationWrite" },
-    );
-
-  const preliminary: AutoBePreliminaryController<
-    | "analysisSections"
-    | "databaseSchemas"
-    | "realizeCollectors"
-    | "realizeTransformers"
-  > = new AutoBePreliminaryController({
-    source: SOURCE,
-    application:
-      typia.json.application<IAutoBeRealizeOperationWriteApplication>(),
-    kinds: [
-      "analysisSections",
-      "databaseSchemas",
-      "realizeCollectors",
-      "realizeTransformers",
-    ],
-    state: ctx.state(),
-    all: {
-      realizeCollectors: props.collectors,
-      realizeTransformers: props.transformers,
-    },
-    local: {
-      realizeCollectors: props.collectors.filter(
-        (c) =>
-          c.plan.dtoTypeName === props.scenario.operation.requestBody?.typeName,
-      ),
-      realizeTransformers: props.transformers.filter(
-        (t) =>
-          t.plan.dtoTypeName ===
-          props.scenario.operation.responseBody?.typeName,
-      ),
-      analysisSections: ragSections,
-    },
-  });
-  return await preliminary.orchestrate(ctx, async (out) => {
-    const pointer: IPointer<IAutoBeRealizeOperationWriteApplication.IComplete | null> =
-      {
-        value: null,
-      };
-    const dto: Record<string, string> =
-      await AutoBeRealizeOperationProgrammer.writeStructures(
-        ctx,
-        props.scenario.operation,
-      );
-    const result: AutoBeContext.IResult = await ctx.conversate({
-      source: "realizeWrite",
-      controller: createController({
-        functionName: props.scenario.functionName,
-        build: (next) => {
-          pointer.value = next;
-        },
-        preliminary,
-      }),
-      enforceFunctionCall: true,
-      promptCacheKey: props.promptCacheKey,
-      ...transformRealizeOperationWriteHistory({
-        state: ctx.state(),
-        scenario: props.scenario,
-        authorization: props.authorization,
-        totalAuthorizations: props.totalAuthorizations,
-        dto,
-        preliminary,
-      }),
-    });
-    if (pointer.value === null) return out(result)(null);
-
-    const functor: AutoBeRealizeOperationFunction = {
-      type: "operation",
-      endpoint: {
-        method: props.scenario.operation.method,
-        path: props.scenario.operation.path,
-      },
-      location: props.scenario.location,
-      name: props.scenario.functionName,
-      content: await AutoBeRealizeOperationProgrammer.replaceImportStatements(
-        ctx,
-        {
-          operation: props.scenario.operation,
-          schemas: props.document.components.schemas,
-          code: pointer.value.revise.final ?? pointer.value.draft,
-          payload: props.authorization?.payload.name,
-        },
-      ),
-    };
-    ctx.dispatch({
-      id: v7(),
-      type: "realizeWrite",
-      function: functor,
-      acquisition: preliminary.getAcquisition(),
-      metric: result.metric,
-      tokenUsage: result.tokenUsage,
-      completed: ++props.progress.completed,
-      total: props.progress.total,
-      step: ctx.state().analyze?.step ?? 0,
-      created_at: new Date().toISOString(),
-    } satisfies AutoBeRealizeWriteEvent);
-    return out(result)(functor);
-  });
-}
-
-function createController(props: {
-  functionName: string;
-  build: (next: IAutoBeRealizeOperationWriteApplication.IComplete) => void;
-  preliminary: AutoBePreliminaryController<
-    | "analysisSections"
-    | "databaseSchemas"
-    | "realizeCollectors"
-    | "realizeTransformers"
-  >;
-}): ILlmController {
-  const validate: Validator = (input) => {
-    const result: IValidation<IAutoBeRealizeOperationWriteApplication.IProps> =
-      typia.validate<IAutoBeRealizeOperationWriteApplication.IProps>(input);
-    if (result.success === false) return result;
-    else if (result.data.request.type !== "complete")
-      return props.preliminary.validate({
-        thinking: result.data.thinking,
-        request: result.data.request,
-      });
-
-    const errors: IValidation.IError[] = validateEmptyCode({
-      name: props.functionName,
-      draft: result.data.request.draft,
-      revise: result.data.request.revise,
-      path: "$input.request",
-      asynchronous: true,
-    });
-    return errors.length
-      ? {
-          success: false,
-          errors,
-          data: result.data,
-        }
-      : result;
-  };
-
-  const application: ILlmApplication = props.preliminary.fixApplication(
-    typia.llm.application<IAutoBeRealizeOperationWriteApplication>({
-      validate: {
-        process: validate,
-      },
-    }),
-  );
-
-  return {
-    protocol: "class",
-    name: SOURCE,
-    application,
-    execute: {
-      process: (next) => {
-        if (next.request.type === "complete") props.build(next.request);
-      },
-    } satisfies IAutoBeRealizeOperationWriteApplication,
-  };
-}
-
-type Validator = (
-  input: unknown,
-) => IValidation<IAutoBeRealizeOperationWriteApplication.IProps>;
-
-const SOURCE = "realizeWrite" satisfies AutoBeEventSource;
+import {
+  AutoBeEventSource,
+  AutoBeOpenApi,
+  AutoBeProgressEventBase,
+  AutoBeRealizeAuthorization,
+  AutoBeRealizeCollectorFunction,
+  AutoBeRealizeOperationFunction,
+  AutoBeRealizeTransformerFunction,
+  AutoBeRealizeWriteEvent,
+} from "@autobe/interface";
+import { IPointer } from "tstl";
+import typia, { ILlmApplication, ILlmController, IValidation } from "typia";
+import { v7 } from "uuid";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { buildAnalysisContextSections } from "../../utils/RAGRetrieval";
+import { executeCachedBatch } from "../../utils/executeCachedBatch";
+import { forceRetry } from "../../utils/forceRetry";
+import { getEmbedder } from "../../utils/getEmbedder";
+import { validateEmptyCode } from "../../utils/validateEmptyCode";
+import { AutoBePreliminaryController } from "../common/AutoBePreliminaryController";
+import { convertToSectionEntries } from "../common/internal/convertToSectionEntries";
+import { IAnalysisSectionEntry } from "../common/structures/IAnalysisSectionEntry";
+import { transformRealizeOperationWriteHistory } from "./histories/transformRealizeOperationWriteHistory";
+import { AutoBeRealizeOperationProgrammer } from "./programmers/AutoBeRealizeOperationProgrammer";
+import { IAutoBeRealizeOperationWriteApplication } from "./structures/IAutoBeRealizeOperationWriteApplication";
+import { IAutoBeRealizeScenarioResult } from "./structures/IAutoBeRealizeScenarioResult";
+
+export async function orchestrateRealizeOperationWrite(
+  ctx: AutoBeContext,
+  props: {
+    authorizations: AutoBeRealizeAuthorization[];
+    collectors: AutoBeRealizeCollectorFunction[];
+    transformers: AutoBeRealizeTransformerFunction[];
+    progress: AutoBeProgressEventBase;
+  },
+): Promise<AutoBeRealizeOperationFunction[]> {
+  const document: AutoBeOpenApi.IDocument = ctx.state().interface!.document;
+  const scenarios: IAutoBeRealizeScenarioResult[] = document.operations.map(
+    (operation) =>
+      AutoBeRealizeOperationProgrammer.getScenario({
+        authorizations: props.authorizations,
+        operation,
+      }),
+  );
+  return await executeCachedBatch(
+    ctx,
+    scenarios.map(
+      (s) => (promptCacheKey) =>
+        forceRetry(() =>
+          process(ctx, {
+            document,
+            totalAuthorizations: props.authorizations,
+            collectors: props.collectors,
+            transformers: props.transformers,
+            authorization: s.decoratorEvent ?? null,
+            scenario: s,
+            progress: props.progress,
+            promptCacheKey,
+          }),
+        ),
+    ),
+  );
+}
+
+async function process(
+  ctx: AutoBeContext,
+  props: {
+    document: AutoBeOpenApi.IDocument;
+    authorization: AutoBeRealizeAuthorization | null;
+    collectors: AutoBeRealizeCollectorFunction[];
+    totalAuthorizations: AutoBeRealizeAuthorization[];
+    scenario: IAutoBeRealizeScenarioResult;
+    transformers: AutoBeRealizeTransformerFunction[];
+    progress: AutoBeProgressEventBase;
+    promptCacheKey: string;
+  },
+): Promise<AutoBeRealizeOperationFunction> {
+  const allSections: IAnalysisSectionEntry[] = convertToSectionEntries(
+    ctx.state().analyze?.files ?? [],
+  );
+
+  const pathSegments = props.scenario.operation.path
+    .split("/")
+    .filter((p) => p && !p.startsWith(":") && !p.startsWith("{"));
+  const queryText: string = [
+    "operation",
+    "write",
+    props.scenario.operation.method,
+    ...pathSegments,
+    props.scenario.functionName,
+  ].join(" ");
+
+  const ragSections: IAnalysisSectionEntry[] =
+    await buildAnalysisContextSections(
+      getEmbedder(),
+      allSections,
+      queryText,
+      "TOPK",
+      { log: false, logPrefix: "realizeOperationWrite" },
+    );
+
+  const preliminary: AutoBePreliminaryController<
+    | "analysisSections"
+    | "databaseSchemas"
+    | "realizeCollectors"
+    | "realizeTransformers"
+  > = new AutoBePreliminaryController({
+    source: SOURCE,
+    application:
+      typia.json.application<IAutoBeRealizeOperationWriteApplication>(),
+    kinds: [
+      "analysisSections",
+      "databaseSchemas",
+      "realizeCollectors",
+      "realizeTransformers",
+    ],
+    state: ctx.state(),
+    all: {
+      realizeCollectors: props.collectors,
+      realizeTransformers: props.transformers,
+    },
+    local: {
+      realizeCollectors: props.collectors.filter(
+        (c) =>
+          c.plan.dtoTypeName === props.scenario.operation.requestBody?.typeName,
+      ),
+      realizeTransformers: props.transformers.filter(
+        (t) =>
+          t.plan.dtoTypeName ===
+          props.scenario.operation.responseBody?.typeName,
+      ),
+      analysisSections: ragSections,
+    },
+  });
+  return await preliminary.orchestrate(ctx, async (out) => {
+    const pointer: IPointer<IAutoBeRealizeOperationWriteApplication.IComplete | null> =
+      {
+        value: null,
+      };
+    const dto: Record<string, string> =
+      await AutoBeRealizeOperationProgrammer.writeStructures(
+        ctx,
+        props.scenario.operation,
+      );
+    const result: AutoBeContext.IResult = await ctx.conversate({
+      source: "realizeWrite",
+      controller: createController({
+        functionName: props.scenario.functionName,
+        build: (next) => {
+          pointer.value = next;
+        },
+        preliminary,
+      }),
+      enforceFunctionCall: true,
+      promptCacheKey: props.promptCacheKey,
+      ...transformRealizeOperationWriteHistory({
+        state: ctx.state(),
+        scenario: props.scenario,
+        authorization: props.authorization,
+        totalAuthorizations: props.totalAuthorizations,
+        dto,
+        preliminary,
+      }),
+    });
+    if (pointer.value === null) return out(result)(null);
+
+    const functor: AutoBeRealizeOperationFunction = {
+      type: "operation",
+      endpoint: {
+        method: props.scenario.operation.method,
+        path: props.scenario.operation.path,
+      },
+      location: props.scenario.location,
+      name: props.scenario.functionName,
+      content: await AutoBeRealizeOperationProgrammer.replaceImportStatements(
+        ctx,
+        {
+          operation: props.scenario.operation,
+          schemas: props.document.components.schemas,
+          code: pointer.value.revise.final ?? pointer.value.draft,
+          payload: props.authorization?.payload.name,
+        },
+      ),
+    };
+    ctx.dispatch({
+      id: v7(),
+      type: "realizeWrite",
+      function: functor,
+      acquisition: preliminary.getAcquisition(),
+      metric: result.metric,
+      tokenUsage: result.tokenUsage,
+      completed: ++props.progress.completed,
+      total: props.progress.total,
+      step: ctx.state().analyze?.step ?? 0,
+      created_at: new Date().toISOString(),
+    } satisfies AutoBeRealizeWriteEvent);
+    return out(result)(functor);
+  });
+}
+
+function createController(props: {
+  functionName: string;
+  build: (next: IAutoBeRealizeOperationWriteApplication.IComplete) => void;
+  preliminary: AutoBePreliminaryController<
+    | "analysisSections"
+    | "databaseSchemas"
+    | "realizeCollectors"
+    | "realizeTransformers"
+  >;
+}): ILlmController {
+  const validate: Validator = (input) => {
+    const result: IValidation<IAutoBeRealizeOperationWriteApplication.IProps> =
+      typia.validate<IAutoBeRealizeOperationWriteApplication.IProps>(input);
+    if (result.success === false) return result;
+    else if (result.data.request.type !== "complete")
+      return props.preliminary.validate({
+        thinking: result.data.thinking,
+        request: result.data.request,
+      });
+
+    const errors: IValidation.IError[] = validateEmptyCode({
+      name: props.functionName,
+      draft: result.data.request.draft,
+      revise: result.data.request.revise,
+      path: "$input.request",
+      asynchronous: true,
+    });
+    return errors.length
+      ? {
+          success: false,
+          errors,
+          data: result.data,
+        }
+      : result;
+  };
+
+  const application: ILlmApplication = props.preliminary.fixApplication(
+    typia.llm.application<IAutoBeRealizeOperationWriteApplication>({
+      validate: {
+        process: validate,
+      },
+    }),
+  );
+
+  return {
+    protocol: "class",
+    name: SOURCE,
+    application,
+    execute: {
+      process: (next) => {
+        if (next.request.type === "complete") props.build(next.request);
+      },
+    } satisfies IAutoBeRealizeOperationWriteApplication,
+  };
+}
+
+type Validator = (
+  input: unknown,
+) => IValidation<IAutoBeRealizeOperationWriteApplication.IProps>;
+
+const SOURCE = "realizeWrite" satisfies AutoBeEventSource;

package/src/orchestrate/realize/orchestrateRealizeTransformer.ts

@@ -1,41 +1,41 @@
-import {
-  AutoBeProgressEventBase,
-  AutoBeRealizeTransformerFunction,
-  AutoBeRealizeTransformerPlan,
-} from "@autobe/interface";
-
-import { AutoBeContext } from "../../context/AutoBeContext";
-import { orchestrateRealizeTransformerCorrectCasting } from "./orchestrateRealizeTransformerCorrectCasting";
-import { orchestrateRealizeTransformerCorrectOverall } from "./orchestrateRealizeTransformerCorrectOverall";
-import { orchestrateRealizeTransformerPlan } from "./orchestrateRealizeTransformerPlan";
-import { orchestrateRealizeTransformerWrite } from "./orchestrateRealizeTransformerWrite";
-
-export async function orchestrateRealizeTransformer(
-  ctx: AutoBeContext,
-  props: {
-    planProgress: AutoBeProgressEventBase;
-    writeProgress: AutoBeProgressEventBase;
-    validateProgress: AutoBeProgressEventBase;
-  },
-): Promise<AutoBeRealizeTransformerFunction[]> {
-  const plans: AutoBeRealizeTransformerPlan[] =
-    await orchestrateRealizeTransformerPlan(ctx, {
-      progress: props.planProgress,
-    });
-  let functions: AutoBeRealizeTransformerFunction[] =
-    await orchestrateRealizeTransformerWrite(ctx, {
-      plans,
-      progress: props.writeProgress,
-    });
-  props.validateProgress.total += functions.length;
-
-  functions = await orchestrateRealizeTransformerCorrectCasting(ctx, {
-    functions,
-    progress: props.validateProgress,
-  });
-  functions = await orchestrateRealizeTransformerCorrectOverall(ctx, {
-    functions,
-    progress: props.validateProgress,
-  });
-  return functions;
-}
+import {
+  AutoBeProgressEventBase,
+  AutoBeRealizeTransformerFunction,
+  AutoBeRealizeTransformerPlan,
+} from "@autobe/interface";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { orchestrateRealizeTransformerCorrectCasting } from "./orchestrateRealizeTransformerCorrectCasting";
+import { orchestrateRealizeTransformerCorrectOverall } from "./orchestrateRealizeTransformerCorrectOverall";
+import { orchestrateRealizeTransformerPlan } from "./orchestrateRealizeTransformerPlan";
+import { orchestrateRealizeTransformerWrite } from "./orchestrateRealizeTransformerWrite";
+
+export async function orchestrateRealizeTransformer(
+  ctx: AutoBeContext,
+  props: {
+    planProgress: AutoBeProgressEventBase;
+    writeProgress: AutoBeProgressEventBase;
+    validateProgress: AutoBeProgressEventBase;
+  },
+): Promise<AutoBeRealizeTransformerFunction[]> {
+  const plans: AutoBeRealizeTransformerPlan[] =
+    await orchestrateRealizeTransformerPlan(ctx, {
+      progress: props.planProgress,
+    });
+  let functions: AutoBeRealizeTransformerFunction[] =
+    await orchestrateRealizeTransformerWrite(ctx, {
+      plans,
+      progress: props.writeProgress,
+    });
+  props.validateProgress.total += functions.length;
+
+  functions = await orchestrateRealizeTransformerCorrectCasting(ctx, {
+    functions,
+    progress: props.validateProgress,
+  });
+  functions = await orchestrateRealizeTransformerCorrectOverall(ctx, {
+    functions,
+    progress: props.validateProgress,
+  });
+  return functions;
+}