@autobe/agent 0.30.0-dev.20260315 → 0.30.1

package/src/orchestrate/realize/orchestrateRealizeAuthorizationWrite.ts

@@ -1,209 +1,209 @@
-import { IAgenticaController } from "@agentica/core";
-import {
-  AutoBeAnalyze,
-  AutoBeEventSource,
-  AutoBeProgressEventBase,
-  AutoBeRealizeAuthorization,
-  AutoBeRealizeAuthorizationWriteEvent,
-  IAutoBeCompiler,
-  IAutoBePrismaCompileResult,
-} from "@autobe/interface";
-import { IPointer } from "tstl";
-import typia, { ILlmApplication, IValidation } from "typia";
-import { v7 } from "uuid";
-
-import { AutoBeContext } from "../../context/AutoBeContext";
-import { executeCachedBatch } from "../../utils/executeCachedBatch";
-import { forceRetry } from "../../utils/forceRetry";
-import { AutoBePreliminaryController } from "../common/AutoBePreliminaryController";
-import { transformRealizeAuthorizationWriteHistory } from "./histories/transformRealizeAuthorizationWriteHistory";
-import { orchestrateRealizeAuthorizationCorrect } from "./orchestrateRealizeAuthorizationCorrect";
-import { IAutoBeRealizeAuthorizationWriteApplication } from "./structures/IAutoBeRealizeAuthorizationWriteApplication";
-import { AuthorizationFileSystem } from "./utils/AuthorizationFileSystem";
-import { InternalFileSystem } from "./utils/InternalFileSystem";
-
-/**
- * 1. Create decorator and its parameters. and design the Authorization Provider.
- * 2. According to Authorization Provider design, create the Provider.
- *
- * @param ctx
- */
-export async function orchestrateRealizeAuthorizationWrite(
-  ctx: AutoBeContext,
-): Promise<AutoBeRealizeAuthorization[]> {
-  ctx.dispatch({
-    type: "realizeAuthorizationStart",
-    id: v7(),
-    step: ctx.state().test?.step ?? 0,
-    created_at: new Date().toISOString(),
-  });
-
-  const actors: AutoBeAnalyze.IActor[] = ctx.state().analyze?.actors ?? [];
-  const progress: AutoBeProgressEventBase = {
-    total: actors.length,
-    completed: 0,
-  };
-  const templates: Record<string, string> = await (
-    await ctx.compiler()
-  ).getTemplate({
-    phase: "realize",
-    dbms: "sqlite",
-  });
-  const authorizations: AutoBeRealizeAuthorization[] = await executeCachedBatch(
-    ctx,
-    actors.map(
-      (a) => (promptCacheKey) =>
-        forceRetry(() =>
-          process(ctx, {
-            actor: a,
-            templates: InternalFileSystem.DEFAULT.map((el) => ({
-              [el]: templates[el],
-            })).reduce((acc, cur) => Object.assign(acc, cur), {}),
-            progress,
-            promptCacheKey,
-          }),
-        ),
-    ),
-  );
-  ctx.dispatch({
-    type: "realizeAuthorizationComplete",
-    id: v7(),
-    created_at: new Date().toISOString(),
-    step: ctx.state().test?.step ?? 0,
-  });
-  return authorizations;
-}
-
-async function process(
-  ctx: AutoBeContext,
-  props: {
-    actor: AutoBeAnalyze.IActor;
-    templates: Record<string, string>;
-    progress: AutoBeProgressEventBase;
-    promptCacheKey: string;
-  },
-): Promise<AutoBeRealizeAuthorization> {
-  const preliminary: AutoBePreliminaryController<"databaseSchemas"> =
-    new AutoBePreliminaryController<"databaseSchemas">({
-      source: SOURCE,
-      application:
-        typia.json.application<IAutoBeRealizeAuthorizationWriteApplication>(),
-      kinds: ["databaseSchemas"],
-      state: ctx.state(),
-    });
-  return await preliminary.orchestrate(ctx, async (out) => {
-    const pointer: IPointer<IAutoBeRealizeAuthorizationWriteApplication.IComplete | null> =
-      {
-        value: null,
-      };
-    const result: AutoBeContext.IResult = await ctx.conversate({
-      source: "realizeAuthorizationWrite",
-      controller: createController({
-        build: (next) => {
-          pointer.value = next;
-        },
-        preliminary,
-      }),
-      enforceFunctionCall: true,
-      promptCacheKey: props.promptCacheKey,
-      ...transformRealizeAuthorizationWriteHistory({
-        actor: props.actor,
-        preliminary,
-      }),
-    });
-    if (pointer.value === null) return out(result)(null);
-
-    const compiler: IAutoBeCompiler = await ctx.compiler();
-    const authorization: AutoBeRealizeAuthorization = {
-      actor: props.actor,
-      decorator: {
-        location: AuthorizationFileSystem.decoratorPath(
-          pointer.value.decorator.name,
-        ),
-        name: pointer.value.decorator.name,
-        content: pointer.value.decorator.content,
-      },
-      payload: {
-        location: AuthorizationFileSystem.payloadPath(
-          pointer.value.payload.name,
-        ),
-        name: pointer.value.payload.name,
-        content: await compiler.typescript.beautify(
-          pointer.value.payload.content,
-        ),
-      },
-      provider: {
-        location: AuthorizationFileSystem.providerPath(
-          pointer.value.provider.name,
-        ),
-        name: pointer.value.provider.name,
-        content: pointer.value.provider.content,
-      },
-    };
-    ctx.dispatch({
-      type: "realizeAuthorizationWrite",
-      id: v7(),
-      created_at: new Date().toISOString(),
-      authorization: authorization,
-      acquisition: preliminary.getAcquisition(),
-      metric: result.metric,
-      tokenUsage: result.tokenUsage,
-      completed: ++props.progress.completed,
-      total: props.progress.total,
-      step: ctx.state().test?.step ?? 0,
-    } satisfies AutoBeRealizeAuthorizationWriteEvent);
-
-    const prismaCompiled: IAutoBePrismaCompileResult | undefined =
-      ctx.state().database?.compiled;
-    const prismaClient: Record<string, string> =
-      prismaCompiled?.type === "success" ? prismaCompiled.client : {};
-    return out(result)(
-      await orchestrateRealizeAuthorizationCorrect(ctx, {
-        template: props.templates,
-        authorization,
-        prismaClient,
-      }),
-    );
-  });
-}
-
-function createController(props: {
-  build: (next: IAutoBeRealizeAuthorizationWriteApplication.IComplete) => void;
-  preliminary: AutoBePreliminaryController<"databaseSchemas">;
-}): IAgenticaController.IClass {
-  const validate: Validator = (input) => {
-    const result: IValidation<IAutoBeRealizeAuthorizationWriteApplication.IProps> =
-      typia.validate<IAutoBeRealizeAuthorizationWriteApplication.IProps>(input);
-    if (result.success === false || result.data.request.type === "complete")
-      return result;
-    return props.preliminary.validate({
-      thinking: result.data.thinking,
-      request: result.data.request,
-    });
-  };
-
-  const application: ILlmApplication = props.preliminary.fixApplication(
-    typia.llm.application<IAutoBeRealizeAuthorizationWriteApplication>({
-      validate: {
-        process: validate,
-      },
-    }),
-  );
-
-  return {
-    protocol: "class",
-    name: SOURCE,
-    application,
-    execute: {
-      process: (next) => {
-        if (next.request.type === "complete") props.build(next.request);
-      },
-    } satisfies IAutoBeRealizeAuthorizationWriteApplication,
-  };
-}
-
-type Validator = (
-  input: unknown,
-) => IValidation<IAutoBeRealizeAuthorizationWriteApplication.IProps>;
-
-const SOURCE = "realizeAuthorizationWrite" satisfies AutoBeEventSource;
+import { IAgenticaController } from "@agentica/core";
+import {
+  AutoBeAnalyze,
+  AutoBeEventSource,
+  AutoBeProgressEventBase,
+  AutoBeRealizeAuthorization,
+  AutoBeRealizeAuthorizationWriteEvent,
+  IAutoBeCompiler,
+  IAutoBePrismaCompileResult,
+} from "@autobe/interface";
+import { IPointer } from "tstl";
+import typia, { ILlmApplication, IValidation } from "typia";
+import { v7 } from "uuid";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { executeCachedBatch } from "../../utils/executeCachedBatch";
+import { forceRetry } from "../../utils/forceRetry";
+import { AutoBePreliminaryController } from "../common/AutoBePreliminaryController";
+import { transformRealizeAuthorizationWriteHistory } from "./histories/transformRealizeAuthorizationWriteHistory";
+import { orchestrateRealizeAuthorizationCorrect } from "./orchestrateRealizeAuthorizationCorrect";
+import { IAutoBeRealizeAuthorizationWriteApplication } from "./structures/IAutoBeRealizeAuthorizationWriteApplication";
+import { AuthorizationFileSystem } from "./utils/AuthorizationFileSystem";
+import { InternalFileSystem } from "./utils/InternalFileSystem";
+
+/**
+ * 1. Create decorator and its parameters. and design the Authorization Provider.
+ * 2. According to Authorization Provider design, create the Provider.
+ *
+ * @param ctx
+ */
+export async function orchestrateRealizeAuthorizationWrite(
+  ctx: AutoBeContext,
+): Promise<AutoBeRealizeAuthorization[]> {
+  ctx.dispatch({
+    type: "realizeAuthorizationStart",
+    id: v7(),
+    step: ctx.state().test?.step ?? 0,
+    created_at: new Date().toISOString(),
+  });
+
+  const actors: AutoBeAnalyze.IActor[] = ctx.state().analyze?.actors ?? [];
+  const progress: AutoBeProgressEventBase = {
+    total: actors.length,
+    completed: 0,
+  };
+  const templates: Record<string, string> = await (
+    await ctx.compiler()
+  ).getTemplate({
+    phase: "realize",
+    dbms: "sqlite",
+  });
+  const authorizations: AutoBeRealizeAuthorization[] = await executeCachedBatch(
+    ctx,
+    actors.map(
+      (a) => (promptCacheKey) =>
+        forceRetry(() =>
+          process(ctx, {
+            actor: a,
+            templates: InternalFileSystem.DEFAULT.map((el) => ({
+              [el]: templates[el],
+            })).reduce((acc, cur) => Object.assign(acc, cur), {}),
+            progress,
+            promptCacheKey,
+          }),
+        ),
+    ),
+  );
+  ctx.dispatch({
+    type: "realizeAuthorizationComplete",
+    id: v7(),
+    created_at: new Date().toISOString(),
+    step: ctx.state().test?.step ?? 0,
+  });
+  return authorizations;
+}
+
+async function process(
+  ctx: AutoBeContext,
+  props: {
+    actor: AutoBeAnalyze.IActor;
+    templates: Record<string, string>;
+    progress: AutoBeProgressEventBase;
+    promptCacheKey: string;
+  },
+): Promise<AutoBeRealizeAuthorization> {
+  const preliminary: AutoBePreliminaryController<"databaseSchemas"> =
+    new AutoBePreliminaryController<"databaseSchemas">({
+      source: SOURCE,
+      application:
+        typia.json.application<IAutoBeRealizeAuthorizationWriteApplication>(),
+      kinds: ["databaseSchemas"],
+      state: ctx.state(),
+    });
+  return await preliminary.orchestrate(ctx, async (out) => {
+    const pointer: IPointer<IAutoBeRealizeAuthorizationWriteApplication.IComplete | null> =
+      {
+        value: null,
+      };
+    const result: AutoBeContext.IResult = await ctx.conversate({
+      source: "realizeAuthorizationWrite",
+      controller: createController({
+        build: (next) => {
+          pointer.value = next;
+        },
+        preliminary,
+      }),
+      enforceFunctionCall: true,
+      promptCacheKey: props.promptCacheKey,
+      ...transformRealizeAuthorizationWriteHistory({
+        actor: props.actor,
+        preliminary,
+      }),
+    });
+    if (pointer.value === null) return out(result)(null);
+
+    const compiler: IAutoBeCompiler = await ctx.compiler();
+    const authorization: AutoBeRealizeAuthorization = {
+      actor: props.actor,
+      decorator: {
+        location: AuthorizationFileSystem.decoratorPath(
+          pointer.value.decorator.name,
+        ),
+        name: pointer.value.decorator.name,
+        content: pointer.value.decorator.content,
+      },
+      payload: {
+        location: AuthorizationFileSystem.payloadPath(
+          pointer.value.payload.name,
+        ),
+        name: pointer.value.payload.name,
+        content: await compiler.typescript.beautify(
+          pointer.value.payload.content,
+        ),
+      },
+      provider: {
+        location: AuthorizationFileSystem.providerPath(
+          pointer.value.provider.name,
+        ),
+        name: pointer.value.provider.name,
+        content: pointer.value.provider.content,
+      },
+    };
+    ctx.dispatch({
+      type: "realizeAuthorizationWrite",
+      id: v7(),
+      created_at: new Date().toISOString(),
+      authorization: authorization,
+      acquisition: preliminary.getAcquisition(),
+      metric: result.metric,
+      tokenUsage: result.tokenUsage,
+      completed: ++props.progress.completed,
+      total: props.progress.total,
+      step: ctx.state().test?.step ?? 0,
+    } satisfies AutoBeRealizeAuthorizationWriteEvent);
+
+    const prismaCompiled: IAutoBePrismaCompileResult | undefined =
+      ctx.state().database?.compiled;
+    const prismaClient: Record<string, string> =
+      prismaCompiled?.type === "success" ? prismaCompiled.client : {};
+    return out(result)(
+      await orchestrateRealizeAuthorizationCorrect(ctx, {
+        template: props.templates,
+        authorization,
+        prismaClient,
+      }),
+    );
+  });
+}
+
+function createController(props: {
+  build: (next: IAutoBeRealizeAuthorizationWriteApplication.IComplete) => void;
+  preliminary: AutoBePreliminaryController<"databaseSchemas">;
+}): IAgenticaController.IClass {
+  const validate: Validator = (input) => {
+    const result: IValidation<IAutoBeRealizeAuthorizationWriteApplication.IProps> =
+      typia.validate<IAutoBeRealizeAuthorizationWriteApplication.IProps>(input);
+    if (result.success === false || result.data.request.type === "complete")
+      return result;
+    return props.preliminary.validate({
+      thinking: result.data.thinking,
+      request: result.data.request,
+    });
+  };
+
+  const application: ILlmApplication = props.preliminary.fixApplication(
+    typia.llm.application<IAutoBeRealizeAuthorizationWriteApplication>({
+      validate: {
+        process: validate,
+      },
+    }),
+  );
+
+  return {
+    protocol: "class",
+    name: SOURCE,
+    application,
+    execute: {
+      process: (next) => {
+        if (next.request.type === "complete") props.build(next.request);
+      },
+    } satisfies IAutoBeRealizeAuthorizationWriteApplication,
+  };
+}
+
+type Validator = (
+  input: unknown,
+) => IValidation<IAutoBeRealizeAuthorizationWriteApplication.IProps>;
+
+const SOURCE = "realizeAuthorizationWrite" satisfies AutoBeEventSource;

package/src/orchestrate/realize/orchestrateRealizeCollector.ts

@@ -1,41 +1,41 @@
-import {
-  AutoBeProgressEventBase,
-  AutoBeRealizeCollectorFunction,
-  AutoBeRealizeCollectorPlan,
-} from "@autobe/interface";
-
-import { AutoBeContext } from "../../context/AutoBeContext";
-import { orchestrateRealizeCollectorCorrectCasting } from "./orchestrateRealizeCollectorCorrectCasting";
-import { orchestrateRealizeCollectorCorrectOverall } from "./orchestrateRealizeCollectorCorrectOverall";
-import { orchestrateRealizeCollectorPlan } from "./orchestrateRealizeCollectorPlan";
-import { orchestrateRealizeCollectorWrite } from "./orchestrateRealizeCollectorWrite";
-
-export async function orchestrateRealizeCollector(
-  ctx: AutoBeContext,
-  props: {
-    planProgress: AutoBeProgressEventBase;
-    writeProgress: AutoBeProgressEventBase;
-    validateProgress: AutoBeProgressEventBase;
-  },
-): Promise<AutoBeRealizeCollectorFunction[]> {
-  const plans: AutoBeRealizeCollectorPlan[] =
-    await orchestrateRealizeCollectorPlan(ctx, {
-      progress: props.planProgress,
-    });
-  let functions: AutoBeRealizeCollectorFunction[] =
-    await orchestrateRealizeCollectorWrite(ctx, {
-      plans,
-      progress: props.writeProgress,
-    });
-  props.validateProgress.total += functions.length;
-
-  functions = await orchestrateRealizeCollectorCorrectCasting(ctx, {
-    functions,
-    progress: props.validateProgress,
-  });
-  functions = await orchestrateRealizeCollectorCorrectOverall(ctx, {
-    functions,
-    progress: props.validateProgress,
-  });
-  return functions;
-}
+import {
+  AutoBeProgressEventBase,
+  AutoBeRealizeCollectorFunction,
+  AutoBeRealizeCollectorPlan,
+} from "@autobe/interface";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { orchestrateRealizeCollectorCorrectCasting } from "./orchestrateRealizeCollectorCorrectCasting";
+import { orchestrateRealizeCollectorCorrectOverall } from "./orchestrateRealizeCollectorCorrectOverall";
+import { orchestrateRealizeCollectorPlan } from "./orchestrateRealizeCollectorPlan";
+import { orchestrateRealizeCollectorWrite } from "./orchestrateRealizeCollectorWrite";
+
+export async function orchestrateRealizeCollector(
+  ctx: AutoBeContext,
+  props: {
+    planProgress: AutoBeProgressEventBase;
+    writeProgress: AutoBeProgressEventBase;
+    validateProgress: AutoBeProgressEventBase;
+  },
+): Promise<AutoBeRealizeCollectorFunction[]> {
+  const plans: AutoBeRealizeCollectorPlan[] =
+    await orchestrateRealizeCollectorPlan(ctx, {
+      progress: props.planProgress,
+    });
+  let functions: AutoBeRealizeCollectorFunction[] =
+    await orchestrateRealizeCollectorWrite(ctx, {
+      plans,
+      progress: props.writeProgress,
+    });
+  props.validateProgress.total += functions.length;
+
+  functions = await orchestrateRealizeCollectorCorrectCasting(ctx, {
+    functions,
+    progress: props.validateProgress,
+  });
+  functions = await orchestrateRealizeCollectorCorrectOverall(ctx, {
+    functions,
+    progress: props.validateProgress,
+  });
+  return functions;
+}

package/src/orchestrate/realize/orchestrateRealizeCollectorCorrectCasting.ts

@@ -1,43 +1,43 @@
-import {
-  AutoBeProgressEventBase,
-  AutoBeRealizeCollectorFunction,
-} from "@autobe/interface";
-
-import { AutoBeContext } from "../../context/AutoBeContext";
-import { orchestrateRealizeCorrectCasting } from "./internal/orchestrateRealizeCorrectCasting";
-import { AutoBeRealizeCollectorProgrammer } from "./programmers/AutoBeRealizeCollectorProgrammer";
-
-export const orchestrateRealizeCollectorCorrectCasting = (
-  ctx: AutoBeContext,
-  props: {
-    functions: AutoBeRealizeCollectorFunction[];
-    progress: AutoBeProgressEventBase;
-  },
-): Promise<AutoBeRealizeCollectorFunction[]> =>
-  orchestrateRealizeCorrectCasting(ctx, {
-    programmer: {
-      template: (func) =>
-        AutoBeRealizeCollectorProgrammer.writeTemplate({
-          plan: func.plan,
-          body: ctx.state().interface!.document.components.schemas[
-            func.plan.dtoTypeName
-          ],
-          model: ctx
-            .state()
-            .database!.result.data.files.map((f) => f.models)
-            .flat()
-            .find((m) => m.name === func.plan.databaseSchemaName)!,
-          application: ctx.state().database!.result.data,
-        }),
-      replaceImportStatements: (next) =>
-        AutoBeRealizeCollectorProgrammer.replaceImportStatements(ctx, {
-          dtoTypeName: next.function.plan.dtoTypeName,
-          schemas: ctx.state().interface!.document.components.schemas,
-          code: next.code,
-        }),
-      additional: () => ({}),
-      location: "src/collectors",
-    },
-    functions: props.functions,
-    progress: props.progress,
-  });
+import {
+  AutoBeProgressEventBase,
+  AutoBeRealizeCollectorFunction,
+} from "@autobe/interface";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { orchestrateRealizeCorrectCasting } from "./internal/orchestrateRealizeCorrectCasting";
+import { AutoBeRealizeCollectorProgrammer } from "./programmers/AutoBeRealizeCollectorProgrammer";
+
+export const orchestrateRealizeCollectorCorrectCasting = (
+  ctx: AutoBeContext,
+  props: {
+    functions: AutoBeRealizeCollectorFunction[];
+    progress: AutoBeProgressEventBase;
+  },
+): Promise<AutoBeRealizeCollectorFunction[]> =>
+  orchestrateRealizeCorrectCasting(ctx, {
+    programmer: {
+      template: (func) =>
+        AutoBeRealizeCollectorProgrammer.writeTemplate({
+          plan: func.plan,
+          body: ctx.state().interface!.document.components.schemas[
+            func.plan.dtoTypeName
+          ],
+          model: ctx
+            .state()
+            .database!.result.data.files.map((f) => f.models)
+            .flat()
+            .find((m) => m.name === func.plan.databaseSchemaName)!,
+          application: ctx.state().database!.result.data,
+        }),
+      replaceImportStatements: (next) =>
+        AutoBeRealizeCollectorProgrammer.replaceImportStatements(ctx, {
+          dtoTypeName: next.function.plan.dtoTypeName,
+          schemas: ctx.state().interface!.document.components.schemas,
+          code: next.code,
+        }),
+      additional: () => ({}),
+      location: "src/collectors",
+    },
+    functions: props.functions,
+    progress: props.progress,
+  });