@autobe/agent 0.30.0-dev.20260315 → 0.30.0

package/src/orchestrate/interface/orchestrateInterface.ts

@@ -1,118 +1,118 @@
-import {
-  AutoBeAssistantMessageHistory,
-  AutoBeInterfaceAuthorization,
-  AutoBeInterfaceCompleteEvent,
-  AutoBeInterfaceEndpointDesign,
-  AutoBeInterfaceGroupEvent,
-  AutoBeInterfaceHistory,
-  AutoBeOpenApi,
-} from "@autobe/interface";
-import { AutoBeInterfacePrerequisiteEvent } from "@autobe/interface/src/events/AutoBeInterfacePrerequisiteEvent";
-import { missedOpenApiSchemas, revertOpenApiAccessor } from "@autobe/utils";
-import { v7 } from "uuid";
-
-import { AutoBeContext } from "../../context/AutoBeContext";
-import { predicateStateMessage } from "../../utils/predicateStateMessage";
-import { IAutoBeFacadeApplicationProps } from "../facade/histories/IAutoBeFacadeApplicationProps";
-import { orchestrateInterfaceAuthorization } from "./orchestrateInterfaceAuthorization";
-import { orchestrateInterfaceEndpoint } from "./orchestrateInterfaceEndpoint";
-import { orchestrateInterfaceGroup } from "./orchestrateInterfaceGroup";
-import { orchestrateInterfaceOperation } from "./orchestrateInterfaceOperation";
-import { orchestrateInterfacePrerequisite } from "./orchestrateInterfacePrerequisite";
-import { orchestrateInterfaceSchema } from "./orchestrateInterfaceSchema";
-
-export const orchestrateInterface =
-  (ctx: AutoBeContext) =>
-  async (
-    props: IAutoBeFacadeApplicationProps,
-  ): Promise<AutoBeAssistantMessageHistory | AutoBeInterfaceHistory> => {
-    // PREDICATION
-    const start: Date = new Date();
-    const predicate: string | null = predicateStateMessage(
-      ctx.state(),
-      "interface",
-    );
-    if (predicate !== null)
-      return ctx.assistantMessage({
-        type: "assistantMessage",
-        id: v7(),
-        created_at: start.toISOString(),
-        text: predicate,
-        completed_at: new Date().toISOString(),
-      });
-    ctx.dispatch({
-      type: "interfaceStart",
-      id: v7(),
-      created_at: start.toISOString(),
-      reason: props.instruction,
-      step: ctx.state().analyze?.step ?? 0,
-    });
-
-    // GROUPS
-    const init: AutoBeInterfaceGroupEvent = await orchestrateInterfaceGroup(
-      ctx,
-      {
-        instruction: props.instruction,
-      },
-    );
-    ctx.dispatch(init);
-
-    // AUTHORIZATION
-    const authorizations: AutoBeInterfaceAuthorization[] =
-      await orchestrateInterfaceAuthorization(ctx, {
-        instruction: props.instruction,
-      });
-
-    // ENDPOINTS
-    const endpoints: AutoBeInterfaceEndpointDesign[] =
-      await orchestrateInterfaceEndpoint(ctx, {
-        instruction: props.instruction,
-        authorizeOperations: authorizations.map((a) => a.operations).flat(),
-        groups: init.groups,
-      });
-
-    // OPERATIONS
-    const operations: AutoBeOpenApi.IOperation[] = [
-      ...authorizations.map((auth) => auth.operations).flat(),
-      ...(await orchestrateInterfaceOperation(ctx, {
-        designs: endpoints,
-        instruction: props.instruction,
-      })),
-    ];
-
-    // THE DOCUMENT WITH SCHEMAS
-    const document: AutoBeOpenApi.IDocument = {
-      operations,
-      components: {
-        authorizations: ctx.state().analyze?.actors ?? [],
-        schemas: await orchestrateInterfaceSchema(ctx, {
-          instruction: props.instruction,
-          operations,
-        }),
-      },
-    };
-    revertOpenApiAccessor(document);
-
-    // PREREQUISITES
-    const prerequisites: AutoBeInterfacePrerequisiteEvent[] =
-      await orchestrateInterfacePrerequisite(ctx, document);
-    document.operations.forEach((op) => {
-      op.prerequisites =
-        prerequisites.find(
-          (p) => p.endpoint.method === op.method && p.endpoint.path === op.path,
-        )?.prerequisites ?? [];
-    });
-
-    // DO COMPILE
-    return ctx.dispatch({
-      type: "interfaceComplete",
-      id: v7(),
-      document,
-      missed: missedOpenApiSchemas(document),
-      authorizations,
-      aggregates: ctx.getCurrentAggregates("interface"),
-      step: ctx.state().analyze?.step ?? 0,
-      elapsed: new Date().getTime() - start.getTime(),
-      created_at: new Date().toISOString(),
-    } satisfies AutoBeInterfaceCompleteEvent);
-  };
+import {
+  AutoBeAssistantMessageHistory,
+  AutoBeInterfaceAuthorization,
+  AutoBeInterfaceCompleteEvent,
+  AutoBeInterfaceEndpointDesign,
+  AutoBeInterfaceGroupEvent,
+  AutoBeInterfaceHistory,
+  AutoBeOpenApi,
+} from "@autobe/interface";
+import { AutoBeInterfacePrerequisiteEvent } from "@autobe/interface/src/events/AutoBeInterfacePrerequisiteEvent";
+import { missedOpenApiSchemas, revertOpenApiAccessor } from "@autobe/utils";
+import { v7 } from "uuid";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { predicateStateMessage } from "../../utils/predicateStateMessage";
+import { IAutoBeFacadeApplicationProps } from "../facade/histories/IAutoBeFacadeApplicationProps";
+import { orchestrateInterfaceAuthorization } from "./orchestrateInterfaceAuthorization";
+import { orchestrateInterfaceEndpoint } from "./orchestrateInterfaceEndpoint";
+import { orchestrateInterfaceGroup } from "./orchestrateInterfaceGroup";
+import { orchestrateInterfaceOperation } from "./orchestrateInterfaceOperation";
+import { orchestrateInterfacePrerequisite } from "./orchestrateInterfacePrerequisite";
+import { orchestrateInterfaceSchema } from "./orchestrateInterfaceSchema";
+
+export const orchestrateInterface =
+  (ctx: AutoBeContext) =>
+  async (
+    props: IAutoBeFacadeApplicationProps,
+  ): Promise<AutoBeAssistantMessageHistory | AutoBeInterfaceHistory> => {
+    // PREDICATION
+    const start: Date = new Date();
+    const predicate: string | null = predicateStateMessage(
+      ctx.state(),
+      "interface",
+    );
+    if (predicate !== null)
+      return ctx.assistantMessage({
+        type: "assistantMessage",
+        id: v7(),
+        created_at: start.toISOString(),
+        text: predicate,
+        completed_at: new Date().toISOString(),
+      });
+    ctx.dispatch({
+      type: "interfaceStart",
+      id: v7(),
+      created_at: start.toISOString(),
+      reason: props.instruction,
+      step: ctx.state().analyze?.step ?? 0,
+    });
+
+    // GROUPS
+    const init: AutoBeInterfaceGroupEvent = await orchestrateInterfaceGroup(
+      ctx,
+      {
+        instruction: props.instruction,
+      },
+    );
+    ctx.dispatch(init);
+
+    // AUTHORIZATION
+    const authorizations: AutoBeInterfaceAuthorization[] =
+      await orchestrateInterfaceAuthorization(ctx, {
+        instruction: props.instruction,
+      });
+
+    // ENDPOINTS
+    const endpoints: AutoBeInterfaceEndpointDesign[] =
+      await orchestrateInterfaceEndpoint(ctx, {
+        instruction: props.instruction,
+        authorizeOperations: authorizations.map((a) => a.operations).flat(),
+        groups: init.groups,
+      });
+
+    // OPERATIONS
+    const operations: AutoBeOpenApi.IOperation[] = [
+      ...authorizations.map((auth) => auth.operations).flat(),
+      ...(await orchestrateInterfaceOperation(ctx, {
+        designs: endpoints,
+        instruction: props.instruction,
+      })),
+    ];
+
+    // THE DOCUMENT WITH SCHEMAS
+    const document: AutoBeOpenApi.IDocument = {
+      operations,
+      components: {
+        authorizations: ctx.state().analyze?.actors ?? [],
+        schemas: await orchestrateInterfaceSchema(ctx, {
+          instruction: props.instruction,
+          operations,
+        }),
+      },
+    };
+    revertOpenApiAccessor(document);
+
+    // PREREQUISITES
+    const prerequisites: AutoBeInterfacePrerequisiteEvent[] =
+      await orchestrateInterfacePrerequisite(ctx, document);
+    document.operations.forEach((op) => {
+      op.prerequisites =
+        prerequisites.find(
+          (p) => p.endpoint.method === op.method && p.endpoint.path === op.path,
+        )?.prerequisites ?? [];
+    });
+
+    // DO COMPILE
+    return ctx.dispatch({
+      type: "interfaceComplete",
+      id: v7(),
+      document,
+      missed: missedOpenApiSchemas(document),
+      authorizations,
+      aggregates: ctx.getCurrentAggregates("interface"),
+      step: ctx.state().analyze?.step ?? 0,
+      elapsed: new Date().getTime() - start.getTime(),
+      created_at: new Date().toISOString(),
+    } satisfies AutoBeInterfaceCompleteEvent);
+  };

package/src/orchestrate/interface/orchestrateInterfaceActionEndpoint.ts

@@ -1,58 +1,58 @@
-import {
-  AutoBeInterfaceEndpointDesign,
-  AutoBeInterfaceGroup,
-  AutoBeOpenApi,
-  AutoBeProgressEventBase,
-} from "@autobe/interface";
-
-import { AutoBeContext } from "../../context/AutoBeContext";
-import { transformInterfaceActionEndpointReviewHistory } from "./histories/transformInterfaceActionEndpointReviewHistory";
-import { transformInterfaceActionEndpointWriteHistory } from "./histories/transformInterfaceActionEndpointWriteHistory";
-import { orchestrateInterfaceEndpointOverall } from "./orchestrateInterfaceEndpointOverall";
-import { orchestrateInterfaceEndpointReview } from "./orchestrateInterfaceEndpointReview";
-
-export const orchestrateInterfaceActionEndpoint = (
-  ctx: AutoBeContext,
-  props: {
-    instruction: string;
-    authorizeOperations: AutoBeOpenApi.IOperation[];
-    groups: AutoBeInterfaceGroup[];
-    baseEndpoints: AutoBeInterfaceEndpointDesign[];
-    progress: AutoBeProgressEventBase;
-    reviewProgress: AutoBeProgressEventBase;
-  },
-): Promise<AutoBeInterfaceEndpointDesign[]> =>
-  orchestrateInterfaceEndpointOverall(ctx, {
-    programmer: {
-      kind: "action",
-      history: (next) =>
-        transformInterfaceActionEndpointWriteHistory({
-          state: ctx.state(),
-          instruction: props.instruction,
-          authorizeOperations: props.authorizeOperations,
-          group: next.group,
-          baseEndpoints: props.baseEndpoints.map((e) => e.endpoint),
-          preliminary: next.preliminary,
-        }),
-      review: (next) =>
-        orchestrateInterfaceEndpointReview(ctx, {
-          programmer: {
-            kind: "action",
-            history: (future) =>
-              transformInterfaceActionEndpointReviewHistory({
-                baseEndpoints: props.baseEndpoints.map((e) => e.endpoint),
-                preliminary: future.preliminary,
-                designs: future.designs,
-                group: future.group,
-                authorizeOperations: props.authorizeOperations,
-              }),
-          },
-          group: next.group,
-          designs: next.designs,
-          promptCacheKey: next.promptCacheKey,
-          progress: props.reviewProgress,
-        }),
-    },
-    groups: props.groups,
-    progress: props.progress,
-  });
+import {
+  AutoBeInterfaceEndpointDesign,
+  AutoBeInterfaceGroup,
+  AutoBeOpenApi,
+  AutoBeProgressEventBase,
+} from "@autobe/interface";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { transformInterfaceActionEndpointReviewHistory } from "./histories/transformInterfaceActionEndpointReviewHistory";
+import { transformInterfaceActionEndpointWriteHistory } from "./histories/transformInterfaceActionEndpointWriteHistory";
+import { orchestrateInterfaceEndpointOverall } from "./orchestrateInterfaceEndpointOverall";
+import { orchestrateInterfaceEndpointReview } from "./orchestrateInterfaceEndpointReview";
+
+export const orchestrateInterfaceActionEndpoint = (
+  ctx: AutoBeContext,
+  props: {
+    instruction: string;
+    authorizeOperations: AutoBeOpenApi.IOperation[];
+    groups: AutoBeInterfaceGroup[];
+    baseEndpoints: AutoBeInterfaceEndpointDesign[];
+    progress: AutoBeProgressEventBase;
+    reviewProgress: AutoBeProgressEventBase;
+  },
+): Promise<AutoBeInterfaceEndpointDesign[]> =>
+  orchestrateInterfaceEndpointOverall(ctx, {
+    programmer: {
+      kind: "action",
+      history: (next) =>
+        transformInterfaceActionEndpointWriteHistory({
+          state: ctx.state(),
+          instruction: props.instruction,
+          authorizeOperations: props.authorizeOperations,
+          group: next.group,
+          baseEndpoints: props.baseEndpoints.map((e) => e.endpoint),
+          preliminary: next.preliminary,
+        }),
+      review: (next) =>
+        orchestrateInterfaceEndpointReview(ctx, {
+          programmer: {
+            kind: "action",
+            history: (future) =>
+              transformInterfaceActionEndpointReviewHistory({
+                baseEndpoints: props.baseEndpoints.map((e) => e.endpoint),
+                preliminary: future.preliminary,
+                designs: future.designs,
+                group: future.group,
+                authorizeOperations: props.authorizeOperations,
+              }),
+          },
+          group: next.group,
+          designs: next.designs,
+          promptCacheKey: next.promptCacheKey,
+          progress: props.reviewProgress,
+        }),
+    },
+    groups: props.groups,
+    progress: props.progress,
+  });