@autobe/agent 0.30.0-dev.20260315 → 0.30.1

package/src/orchestrate/prisma/orchestratePrismaSchemaReview.ts

@@ -1,220 +1,220 @@
-import { IAgenticaController } from "@agentica/core";
-import {
-  AutoBeDatabase,
-  AutoBeDatabaseComponent,
-  AutoBeDatabaseSchemaReviewEvent,
-  AutoBeEventSource,
-  AutoBeProgressEventBase,
-} 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 { AutoBePreliminaryController } from "../common/AutoBePreliminaryController";
-import { transformPrismaSchemaReviewHistory } from "./histories/transformPrismaSchemaReviewHistory";
-import { AutoBeDatabaseSchemaProgrammer } from "./programmers/AutoBeDatabaseSchemaProgrammer";
-import { IAutoBeDatabaseSchemaReviewApplication } from "./structures/IAutoBeDatabaseSchemaReviewApplication";
-
-export async function orchestratePrismaSchemaReview(
-  ctx: AutoBeContext,
-  props: {
-    application: AutoBeDatabase.IApplication;
-    components: AutoBeDatabaseComponent[];
-    reviewed: Set<string>;
-    progress: AutoBeProgressEventBase;
-  },
-): Promise<AutoBeDatabaseSchemaReviewEvent[]> {
-  // Flatten into individual model tasks, skipping already-reviewed models
-  const tableTasks: Array<{
-    component: AutoBeDatabaseComponent;
-    table: string;
-    model: AutoBeDatabase.IModel;
-  }> = props.components.flatMap((component) => {
-    const file: AutoBeDatabase.IFile | undefined = props.application.files.find(
-      (f) => f.namespace === component.namespace,
-    );
-    if (file === undefined) return [];
-    return file.models
-      .filter((m) => !props.reviewed.has(m.name))
-      .map((model) => ({ component, table: model.name, model }));
-  });
-  if (tableTasks.length === 0) return [];
-
-  props.progress.total += tableTasks.length;
-
-  return (
-    await executeCachedBatch(
-      ctx,
-      tableTasks.map((task) => async (promptCacheKey) => {
-        try {
-          return await step(ctx, {
-            application: props.application,
-            component: task.component,
-            model: task.model,
-            otherModels: props.application.files
-              .flatMap((f) => f.models)
-              .filter((m) => m.name !== task.model.name),
-            progress: props.progress,
-            promptCacheKey,
-          });
-        } catch {
-          ++props.progress.completed;
-          return null;
-        }
-      }),
-    )
-  ).filter((v) => v !== null);
-}
-
-async function step(
-  ctx: AutoBeContext,
-  props: {
-    application: AutoBeDatabase.IApplication;
-    component: AutoBeDatabaseComponent;
-    model: AutoBeDatabase.IModel;
-    otherModels: AutoBeDatabase.IModel[];
-    progress: AutoBeProgressEventBase;
-    promptCacheKey: string;
-  },
-): Promise<AutoBeDatabaseSchemaReviewEvent> {
-  const start: Date = new Date();
-  const preliminary: AutoBePreliminaryController<
-    | "analysisSections"
-    | "databaseSchemas"
-    | "previousAnalysisSections"
-    | "previousDatabaseSchemas"
-  > = new AutoBePreliminaryController({
-    application:
-      typia.json.application<IAutoBeDatabaseSchemaReviewApplication>(),
-    source: SOURCE,
-    kinds: [
-      "analysisSections",
-      "databaseSchemas",
-      "previousAnalysisSections",
-      "previousDatabaseSchemas",
-    ],
-    state: ctx.state(),
-    all: {
-      databaseSchemas: props.application.files.map((f) => f.models).flat(),
-    },
-    local: {
-      databaseSchemas: [props.model],
-    },
-    config: {
-      database: "ast",
-    },
-  });
-  return await preliminary.orchestrate(ctx, async (out) => {
-    const pointer: IPointer<IAutoBeDatabaseSchemaReviewApplication.IComplete | null> =
-      {
-        value: null,
-      };
-    const result: AutoBeContext.IResult = await ctx.conversate({
-      source: SOURCE,
-      controller: createController({
-        preliminary,
-        build: (next) => {
-          pointer.value = next;
-        },
-        targetComponent: props.component,
-        model: props.model,
-        otherModels: props.otherModels,
-      }),
-      enforceFunctionCall: true,
-      promptCacheKey: props.promptCacheKey,
-      ...transformPrismaSchemaReviewHistory({
-        component: props.component,
-        model: props.model,
-        otherModels: props.otherModels,
-        preliminary,
-      }),
-    });
-    if (pointer.value === null) return out(result)(null);
-
-    const event: AutoBeDatabaseSchemaReviewEvent = {
-      type: SOURCE,
-      id: v7(),
-      created_at: start.toISOString(),
-      namespace: props.component.namespace,
-      review: pointer.value.review,
-      plan: pointer.value.plan,
-      modelName: props.model.name,
-      content: pointer.value.content,
-      acquisition: preliminary.getAcquisition(),
-      metric: result.metric,
-      tokenUsage: result.tokenUsage,
-      completed: ++props.progress.completed,
-      total: props.progress.total,
-      step: ctx.state().analyze?.step ?? 0,
-    };
-    ctx.dispatch(event);
-    return out(result)(event);
-  });
-}
-
-function createController(props: {
-  preliminary: AutoBePreliminaryController<
-    | "analysisSections"
-    | "previousAnalysisSections"
-    | "databaseSchemas"
-    | "previousDatabaseSchemas"
-  >;
-  build: (next: IAutoBeDatabaseSchemaReviewApplication.IComplete) => void;
-  targetComponent: AutoBeDatabaseComponent;
-  model: AutoBeDatabase.IModel;
-  otherModels: AutoBeDatabase.IModel[];
-}): IAgenticaController.IClass {
-  const validate = (
-    input: unknown,
-  ): IValidation<IAutoBeDatabaseSchemaReviewApplication.IProps> => {
-    const result: IValidation<IAutoBeDatabaseSchemaReviewApplication.IProps> =
-      typia.validate<IAutoBeDatabaseSchemaReviewApplication.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,
-      });
-    else if (result.data.request.content === null) return result;
-
-    const errors: IValidation.IError[] = [];
-    if (result.data.request.content !== null)
-      AutoBeDatabaseSchemaProgrammer.validate({
-        path: "$input.request.content",
-        errors,
-        targetTable: props.model.name,
-        otherTables: props.otherModels.map((m) => m.name),
-        definition: result.data.request.content,
-      });
-
-    if (errors.length !== 0)
-      return {
-        success: false,
-        data: result.data,
-        errors,
-      };
-    return result;
-  };
-
-  const application: ILlmApplication = props.preliminary.fixApplication(
-    typia.llm.application<IAutoBeDatabaseSchemaReviewApplication>({
-      validate: {
-        process: validate,
-      },
-    }),
-  );
-  return {
-    protocol: "class",
-    name: SOURCE,
-    application,
-    execute: {
-      process: (next) => {
-        if (next.request.type === "complete") props.build(next.request);
-      },
-    } satisfies IAutoBeDatabaseSchemaReviewApplication,
-  };
-}
-
-const SOURCE = "databaseSchemaReview" satisfies AutoBeEventSource;
+import { IAgenticaController } from "@agentica/core";
+import {
+  AutoBeDatabase,
+  AutoBeDatabaseComponent,
+  AutoBeDatabaseSchemaReviewEvent,
+  AutoBeEventSource,
+  AutoBeProgressEventBase,
+} 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 { AutoBePreliminaryController } from "../common/AutoBePreliminaryController";
+import { transformPrismaSchemaReviewHistory } from "./histories/transformPrismaSchemaReviewHistory";
+import { AutoBeDatabaseSchemaProgrammer } from "./programmers/AutoBeDatabaseSchemaProgrammer";
+import { IAutoBeDatabaseSchemaReviewApplication } from "./structures/IAutoBeDatabaseSchemaReviewApplication";
+
+export async function orchestratePrismaSchemaReview(
+  ctx: AutoBeContext,
+  props: {
+    application: AutoBeDatabase.IApplication;
+    components: AutoBeDatabaseComponent[];
+    reviewed: Set<string>;
+    progress: AutoBeProgressEventBase;
+  },
+): Promise<AutoBeDatabaseSchemaReviewEvent[]> {
+  // Flatten into individual model tasks, skipping already-reviewed models
+  const tableTasks: Array<{
+    component: AutoBeDatabaseComponent;
+    table: string;
+    model: AutoBeDatabase.IModel;
+  }> = props.components.flatMap((component) => {
+    const file: AutoBeDatabase.IFile | undefined = props.application.files.find(
+      (f) => f.namespace === component.namespace,
+    );
+    if (file === undefined) return [];
+    return file.models
+      .filter((m) => !props.reviewed.has(m.name))
+      .map((model) => ({ component, table: model.name, model }));
+  });
+  if (tableTasks.length === 0) return [];
+
+  props.progress.total += tableTasks.length;
+
+  return (
+    await executeCachedBatch(
+      ctx,
+      tableTasks.map((task) => async (promptCacheKey) => {
+        try {
+          return await step(ctx, {
+            application: props.application,
+            component: task.component,
+            model: task.model,
+            otherModels: props.application.files
+              .flatMap((f) => f.models)
+              .filter((m) => m.name !== task.model.name),
+            progress: props.progress,
+            promptCacheKey,
+          });
+        } catch {
+          ++props.progress.completed;
+          return null;
+        }
+      }),
+    )
+  ).filter((v) => v !== null);
+}
+
+async function step(
+  ctx: AutoBeContext,
+  props: {
+    application: AutoBeDatabase.IApplication;
+    component: AutoBeDatabaseComponent;
+    model: AutoBeDatabase.IModel;
+    otherModels: AutoBeDatabase.IModel[];
+    progress: AutoBeProgressEventBase;
+    promptCacheKey: string;
+  },
+): Promise<AutoBeDatabaseSchemaReviewEvent> {
+  const start: Date = new Date();
+  const preliminary: AutoBePreliminaryController<
+    | "analysisSections"
+    | "databaseSchemas"
+    | "previousAnalysisSections"
+    | "previousDatabaseSchemas"
+  > = new AutoBePreliminaryController({
+    application:
+      typia.json.application<IAutoBeDatabaseSchemaReviewApplication>(),
+    source: SOURCE,
+    kinds: [
+      "analysisSections",
+      "databaseSchemas",
+      "previousAnalysisSections",
+      "previousDatabaseSchemas",
+    ],
+    state: ctx.state(),
+    all: {
+      databaseSchemas: props.application.files.map((f) => f.models).flat(),
+    },
+    local: {
+      databaseSchemas: [props.model],
+    },
+    config: {
+      database: "ast",
+    },
+  });
+  return await preliminary.orchestrate(ctx, async (out) => {
+    const pointer: IPointer<IAutoBeDatabaseSchemaReviewApplication.IComplete | null> =
+      {
+        value: null,
+      };
+    const result: AutoBeContext.IResult = await ctx.conversate({
+      source: SOURCE,
+      controller: createController({
+        preliminary,
+        build: (next) => {
+          pointer.value = next;
+        },
+        targetComponent: props.component,
+        model: props.model,
+        otherModels: props.otherModels,
+      }),
+      enforceFunctionCall: true,
+      promptCacheKey: props.promptCacheKey,
+      ...transformPrismaSchemaReviewHistory({
+        component: props.component,
+        model: props.model,
+        otherModels: props.otherModels,
+        preliminary,
+      }),
+    });
+    if (pointer.value === null) return out(result)(null);
+
+    const event: AutoBeDatabaseSchemaReviewEvent = {
+      type: SOURCE,
+      id: v7(),
+      created_at: start.toISOString(),
+      namespace: props.component.namespace,
+      review: pointer.value.review,
+      plan: pointer.value.plan,
+      modelName: props.model.name,
+      content: pointer.value.content,
+      acquisition: preliminary.getAcquisition(),
+      metric: result.metric,
+      tokenUsage: result.tokenUsage,
+      completed: ++props.progress.completed,
+      total: props.progress.total,
+      step: ctx.state().analyze?.step ?? 0,
+    };
+    ctx.dispatch(event);
+    return out(result)(event);
+  });
+}
+
+function createController(props: {
+  preliminary: AutoBePreliminaryController<
+    | "analysisSections"
+    | "previousAnalysisSections"
+    | "databaseSchemas"
+    | "previousDatabaseSchemas"
+  >;
+  build: (next: IAutoBeDatabaseSchemaReviewApplication.IComplete) => void;
+  targetComponent: AutoBeDatabaseComponent;
+  model: AutoBeDatabase.IModel;
+  otherModels: AutoBeDatabase.IModel[];
+}): IAgenticaController.IClass {
+  const validate = (
+    input: unknown,
+  ): IValidation<IAutoBeDatabaseSchemaReviewApplication.IProps> => {
+    const result: IValidation<IAutoBeDatabaseSchemaReviewApplication.IProps> =
+      typia.validate<IAutoBeDatabaseSchemaReviewApplication.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,
+      });
+    else if (result.data.request.content === null) return result;
+
+    const errors: IValidation.IError[] = [];
+    if (result.data.request.content !== null)
+      AutoBeDatabaseSchemaProgrammer.validate({
+        path: "$input.request.content",
+        errors,
+        targetTable: props.model.name,
+        otherTables: props.otherModels.map((m) => m.name),
+        definition: result.data.request.content,
+      });
+
+    if (errors.length !== 0)
+      return {
+        success: false,
+        data: result.data,
+        errors,
+      };
+    return result;
+  };
+
+  const application: ILlmApplication = props.preliminary.fixApplication(
+    typia.llm.application<IAutoBeDatabaseSchemaReviewApplication>({
+      validate: {
+        process: validate,
+      },
+    }),
+  );
+  return {
+    protocol: "class",
+    name: SOURCE,
+    application,
+    execute: {
+      process: (next) => {
+        if (next.request.type === "complete") props.build(next.request);
+      },
+    } satisfies IAutoBeDatabaseSchemaReviewApplication,
+  };
+}
+
+const SOURCE = "databaseSchemaReview" satisfies AutoBeEventSource;

package/src/orchestrate/prisma/programmers/AutoBeDatabaseAuthorizationProgrammer.ts

@@ -1,86 +1,86 @@
-import {
-  AutoBeAnalyze,
-  AutoBeDatabaseComponentTableDesign,
-} from "@autobe/interface";
-import { StringUtil } from "@autobe/utils";
-import { NamingConvention } from "@typia/utils";
-import { plural } from "pluralize";
-import { IValidation } from "typia";
-
-import { AutoBeDatabaseComponentProgrammer } from "./AutoBeDatabaseComponentProgrammer";
-
-export namespace AutoBeDatabaseAuthorizationProgrammer {
-  /** Validate authorization tables for an actor. */
-  export const validate = (props: {
-    errors: IValidation.IError[];
-    path: string;
-    prefix: string | null;
-    actors: AutoBeAnalyze.IActor[];
-    tables: AutoBeDatabaseComponentTableDesign[];
-  }): void => {
-    // validate common logic
-    AutoBeDatabaseComponentProgrammer.validate(props);
-
-    // Validation: all tables must contain actor name
-    const prefix: string = props.prefix ? `${props.prefix}_` : "";
-    const actorNames: string[] = props.actors.map(
-      (actor) => prefix + NamingConvention.snake(actor.name),
-    );
-    props.tables.forEach((table, i) => {
-      if (actorNames.some((an) => table.name.startsWith(an)) === false)
-        props.errors.push({
-          path: `${props.path}[${i}].name`,
-          expected: `\`\${${actorNames.map((s) => JSON.stringify(s)).join(" | ")}}\${string}\``,
-          value: table.name,
-          description: StringUtil.trim`
-            Table "${table.name}" does not start with none of below:
-
-            ${actorNames.map((an) => `- "${an}"`).join("\n")}
-
-            Fix: Add one of above to the table name, or remove this table
-            if it is unrelated to some actor.
-          `,
-        });
-    });
-
-    for (const actor of props.actors) {
-      // Validation: actor table must exist
-      const name: string = NamingConvention.snake(actor.name);
-      const tableNames: string[] = props.tables.map((t) => t.name);
-      const expectedActorTable: string = `${prefix}${plural(name)}`;
-      if (tableNames.includes(expectedActorTable) === false)
-        props.errors.push({
-          path: props.path,
-          expected: StringUtil.trim`{
-            name: ${JSON.stringify(expectedActorTable)};
-            description: string;
-          }`,
-          value: undefined,
-          description: StringUtil.trim`
-            Missing required actor table "${expectedActorTable}".
-
-            Fix: Add table "${expectedActorTable}", or rename the table that
-            serves as the main "${actor.name}" actor entity.
-          `,
-        });
-
-      // Validation: session table must exist
-      const expectedSessionTable: string = `${prefix}${name}_sessions`;
-      if (tableNames.includes(expectedSessionTable) === false)
-        props.errors.push({
-          path: props.path,
-          expected: StringUtil.trim`{
-            name: ${JSON.stringify(expectedSessionTable)};
-            description: string;
-          }`,
-          value: undefined,
-          description: StringUtil.trim`
-            Missing required session table "${expectedSessionTable}".
-
-            Fix: Add table "${expectedSessionTable}" for authentication
-            session management of "${actor.name}" actor.
-          `,
-        });
-    }
-  };
-}
+import {
+  AutoBeAnalyze,
+  AutoBeDatabaseComponentTableDesign,
+} from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+import { NamingConvention } from "@typia/utils";
+import { plural } from "pluralize";
+import { IValidation } from "typia";
+
+import { AutoBeDatabaseComponentProgrammer } from "./AutoBeDatabaseComponentProgrammer";
+
+export namespace AutoBeDatabaseAuthorizationProgrammer {
+  /** Validate authorization tables for an actor. */
+  export const validate = (props: {
+    errors: IValidation.IError[];
+    path: string;
+    prefix: string | null;
+    actors: AutoBeAnalyze.IActor[];
+    tables: AutoBeDatabaseComponentTableDesign[];
+  }): void => {
+    // validate common logic
+    AutoBeDatabaseComponentProgrammer.validate(props);
+
+    // Validation: all tables must contain actor name
+    const prefix: string = props.prefix ? `${props.prefix}_` : "";
+    const actorNames: string[] = props.actors.map(
+      (actor) => prefix + NamingConvention.snake(actor.name),
+    );
+    props.tables.forEach((table, i) => {
+      if (actorNames.some((an) => table.name.startsWith(an)) === false)
+        props.errors.push({
+          path: `${props.path}[${i}].name`,
+          expected: `\`\${${actorNames.map((s) => JSON.stringify(s)).join(" | ")}}\${string}\``,
+          value: table.name,
+          description: StringUtil.trim`
+            Table "${table.name}" does not start with none of below:
+
+            ${actorNames.map((an) => `- "${an}"`).join("\n")}
+
+            Fix: Add one of above to the table name, or remove this table
+            if it is unrelated to some actor.
+          `,
+        });
+    });
+
+    for (const actor of props.actors) {
+      // Validation: actor table must exist
+      const name: string = NamingConvention.snake(actor.name);
+      const tableNames: string[] = props.tables.map((t) => t.name);
+      const expectedActorTable: string = `${prefix}${plural(name)}`;
+      if (tableNames.includes(expectedActorTable) === false)
+        props.errors.push({
+          path: props.path,
+          expected: StringUtil.trim`{
+            name: ${JSON.stringify(expectedActorTable)};
+            description: string;
+          }`,
+          value: undefined,
+          description: StringUtil.trim`
+            Missing required actor table "${expectedActorTable}".
+
+            Fix: Add table "${expectedActorTable}", or rename the table that
+            serves as the main "${actor.name}" actor entity.
+          `,
+        });
+
+      // Validation: session table must exist
+      const expectedSessionTable: string = `${prefix}${name}_sessions`;
+      if (tableNames.includes(expectedSessionTable) === false)
+        props.errors.push({
+          path: props.path,
+          expected: StringUtil.trim`{
+            name: ${JSON.stringify(expectedSessionTable)};
+            description: string;
+          }`,
+          value: undefined,
+          description: StringUtil.trim`
+            Missing required session table "${expectedSessionTable}".
+
+            Fix: Add table "${expectedSessionTable}" for authentication
+            session management of "${actor.name}" actor.
+          `,
+        });
+    }
+  };
+}