@autobe/agent 0.30.0-dev.20260315 → 0.30.1

package/src/factory/getAutoBeGenerated.ts

@@ -1,317 +1,317 @@
-import {
-  AutoBeAnalyzeHistory,
-  AutoBeDatabaseHistory,
-  AutoBeHistory,
-  AutoBeInterfaceHistory,
-  AutoBeProcessAggregateCollection,
-  AutoBeRealizeHistory,
-  AutoBeTestHistory,
-  AutoBeUserMessageTextContent,
-  IAutoBeCompiler,
-  IAutoBeGetFilesOptions,
-} from "@autobe/interface";
-import { AutoBeProcessAggregateFactory } from "@autobe/utils";
-
-import { AutoBeState } from "../context/AutoBeState";
-import { AutoBeTokenUsage } from "../context/AutoBeTokenUsage";
-import { getAutoBeRealizeGenerated } from "./getAutoBeRealizeGenerated";
-
-/**
- * Aggregates all generated files from the development pipeline into a complete
- * project structure.
- *
- * Collects artifacts from all completed phases (Analyze, Database, Interface,
- * Test, Realize) and assembles them into a deployable project with proper
- * directory organization. Includes requirements documentation, database
- * schemas, API specifications, implementation code, test suites, and benchmark
- * reports.
- *
- * The phase option controls which artifacts are included, enabling incremental
- * file generation as development progresses through the pipeline stages.
- *
- * @param props Configuration including compiler, current state, histories, and
- *   options specifying target phase and database system
- * @returns File paths mapped to complete contents for all generated artifacts
- */
-export async function getAutoBeGenerated(props: {
-  compiler: IAutoBeCompiler;
-  state: AutoBeState;
-  histories: Readonly<AutoBeHistory[]>;
-  tokenUsage: AutoBeTokenUsage;
-  options?: Partial<IAutoBeGetFilesOptions>;
-}): Promise<Record<string, string>> {
-  const options: Required<IAutoBeGetFilesOptions> = {
-    phase:
-      (props.options?.phase ?? props.state.realize)
-        ? "realize"
-        : props.state.test
-          ? "test"
-          : props.state.interface
-            ? "interface"
-            : "analyze",
-    dbms: props.options?.dbms ?? "postgres",
-  };
-  const ret: Record<string, string> = await props.compiler.getTemplate(options);
-  ret["README.md"] = writeReadMe(props.state, ret["README.md"]);
-  if (props.state.analyze === null) return ret;
-
-  // ANALYZE
-  Object.assign<Record<string, string>, Record<string, string>>(
-    ret,
-    Object.fromEntries(
-      props.state.analyze.files.map((file) => [
-        `docs/analysis/${file.filename.split("/").at(-1)}`,
-        file.content,
-      ]),
-    ),
-  );
-  // ANALYZE - USER MESSAGES
-  const contents: AutoBeUserMessageTextContent[] = props.histories
-    .filter((h) => h.type === "userMessage")
-    .flatMap((h) => h.contents)
-    .filter((c) => c.type === "text");
-  Object.assign<Record<string, string>, Record<string, string>>(
-    ret,
-    Object.fromEntries(
-      contents.map((c, i) => [
-        `docs/user-message/user.message.${i + 1}.md`,
-        c.text,
-      ]),
-    ),
-  );
-  if (props.options?.phase === "analyze") return ret;
-
-  // PRISMA
-  if (props.state.database?.step === props.state.analyze.step) {
-    const schemaFiles: Record<string, string> =
-      await props.compiler.database.writePrismaSchemas(
-        props.state.database.result.data,
-        options!.dbms!,
-      );
-    Object.assign<
-      Record<string, string>,
-      Record<string, string>,
-      Record<string, string>
-    >(
-      ret,
-      Object.fromEntries(
-        Object.entries(schemaFiles).map(([key, value]) => [
-          `prisma/schema/${key.split("/").at(-1)}`,
-          value,
-        ]),
-      ),
-      {
-        "autobe/prisma.json": JSON.stringify(props.state.database.result.data),
-      },
-    );
-    if (props.state.database.compiled.type === "success")
-      ret["docs/ERD.md"] = props.state.database.compiled.document;
-    else if (props.state.database.compiled.type === "failure")
-      ret["prisma/compile-error-reason.log"] =
-        props.state.database.compiled.reason;
-  }
-  if (props.options?.phase === "database") return ret;
-
-  // INTERFACE
-  if (props.state.interface?.step === props.state.analyze.step) {
-    const files: Record<string, string> = await props.compiler.interface.write(
-      props.state.interface.document,
-      Object.keys(ret),
-    );
-    Object.assign<
-      Record<string, string>,
-      Record<string, string>,
-      Record<string, string>
-    >(
-      ret,
-      props.state.test?.step === props.state.interface.step
-        ? Object.fromEntries(
-            Object.entries(files).filter(
-              ([key]) => key.startsWith("test/features/") === false,
-            ),
-          )
-        : files,
-      {
-        "autobe/document.json": JSON.stringify(props.state.interface.document),
-      },
-    );
-  }
-  if (props.options?.phase === "interface") return ret;
-
-  // TEST
-  if (props.state.test?.step === props.state.analyze.step)
-    Object.assign<Record<string, string>, Record<string, string>>(
-      ret,
-      Object.fromEntries(
-        props.state.test.functions.map((f) => [f.location, f.content]),
-      ),
-    );
-
-  // REALIZE
-  if (props.state.realize?.step === props.state.analyze.step)
-    Object.assign<Record<string, string>, Record<string, string>>(
-      ret,
-      await getAutoBeRealizeGenerated({
-        compiler: props.compiler,
-        document: props.state.interface!.document,
-        authorizations: props.state.realize.authorizations,
-        functions: props.state.realize.functions,
-        options: {
-          dbms: options?.dbms ?? "postgres",
-        },
-      }),
-    );
-  if (props.options?.phase === "test") return ret;
-
-  // LOGGING
-  Object.assign<Record<string, string>, Record<string, string>>(ret, {
-    "autobe/histories.json": JSON.stringify(props.histories),
-    "autobe/tokenUsage.json": JSON.stringify(props.tokenUsage),
-  });
-  return ret;
-}
-
-function writeReadMe(state: AutoBeState, readme: string): string {
-  const emoji = (
-    history:
-      | AutoBeAnalyzeHistory
-      | AutoBeDatabaseHistory
-      | AutoBeInterfaceHistory
-      | AutoBeTestHistory
-      | AutoBeRealizeHistory
-      | null,
-  ): string => (history ? (success(history) ? "✅" : "❌") : "⬜");
-  return readme
-    .replaceAll("{{ANALYSIS_EMOJI}}", emoji(state.analyze))
-    .replaceAll("{{DATABASE_EMOJI}}", emoji(state.database))
-    .replaceAll("{{INTERFACE_EMOJI}}", emoji(state.interface))
-    .replaceAll("{{TEST_EMOJI}}", emoji(state.test))
-    .replaceAll("{{REALIZE_EMOJI}}", emoji(state.realize))
-    .replaceAll("{{BENCHMARK_AGGREGATE}}", writeBenchmarkAggregate(state))
-    .replaceAll(
-      "{{BENCHMARK_FUNCTION_CALLING}}",
-      writeBenchmarkFunctionCalling(state),
-    );
-}
-
-function writeBenchmarkAggregate(state: AutoBeState): string {
-  return (["analyze", "database", "interface", "test", "realize"] as const)
-    .map((key) => {
-      const h = state[key];
-      if (h === null) return `⬜ ${key} | | | | `;
-      return [
-        `${success(h) ? "✅" : "❌"} ${h.type}`,
-        Object.entries(label(h))
-          .map(([k, v]) => `${k}: ${v.toLocaleString()}`)
-          .join(", "),
-        (
-          (h.aggregates.total.metric.success /
-            h.aggregates.total.metric.attempt) *
-          100
-        ).toFixed(2) + " %",
-        h.aggregates.total.tokenUsage.total.toLocaleString(),
-        Math.round(
-          (new Date(h.completed_at).getTime() -
-            new Date(h.created_at).getTime()) /
-            1_000,
-        ) + " sec",
-      ].join(" | ");
-    })
-    .join("\n");
-}
-
-function writeBenchmarkFunctionCalling(state: AutoBeState): string {
-  const aggregates: AutoBeProcessAggregateCollection =
-    AutoBeProcessAggregateFactory.reduce(
-      [
-        state.analyze,
-        state.database,
-        state.interface,
-        state.test,
-        state.realize,
-      ]
-        .filter((h) => h !== null)
-        .map((h) => h.aggregates),
-    );
-  return Object.entries(aggregates)
-    .map(([key, value]) =>
-      [
-        key,
-        value.metric.attempt.toLocaleString(),
-        value.metric.validationFailure.toLocaleString(),
-        value.metric.invalidJson.toLocaleString(),
-        value.metric.success.toLocaleString(),
-        ((value.metric.success / value.metric.attempt) * 100).toFixed(2) + " %",
-      ].join(" | "),
-    )
-    .join("\n");
-}
-
-function success(
-  history:
-    | AutoBeAnalyzeHistory
-    | AutoBeDatabaseHistory
-    | AutoBeInterfaceHistory
-    | AutoBeTestHistory
-    | AutoBeRealizeHistory,
-): boolean {
-  if (history.type === "analyze") return true;
-  else if (history.type === "interface") return history.missed.length === 0;
-  else if (
-    history.type === "database" ||
-    history.type === "test" ||
-    history.type === "realize"
-  )
-    return history.compiled.type === "success";
-  history satisfies never;
-  throw new Error("Unknown history type encountered.");
-}
-
-function label(
-  history:
-    | AutoBeAnalyzeHistory
-    | AutoBeDatabaseHistory
-    | AutoBeInterfaceHistory
-    | AutoBeTestHistory
-    | AutoBeRealizeHistory,
-): Record<string, number> {
-  if (history.type === "analyze")
-    return {
-      actors: history.actors.length,
-      documents: history.files.length,
-    };
-  else if (history.type === "database")
-    return {
-      namespaces: history.result.data.files.length,
-      models: history.result.data.files.map((f) => f.models).flat().length,
-    };
-  else if (history.type === "interface")
-    return {
-      operations: history.document.operations.length,
-      schemas: Object.keys(history.document.components.schemas).length,
-    };
-  else if (history.type === "test") {
-    return {
-      functions: history.functions.length,
-      ...(history.compiled.type === "failure"
-        ? {
-            errors: new Set(
-              history.compiled.diagnostics.map((d) => d.file ?? ""),
-            ).size,
-          }
-        : {}),
-    };
-  } else if (history.type === "realize")
-    return {
-      functions: history.functions.length,
-      ...(history.compiled.type === "failure"
-        ? {
-            errors: new Set(
-              history.compiled.diagnostics.map((d) => d.file ?? ""),
-            ).size,
-          }
-        : {}),
-    };
-  history satisfies never;
-  throw new Error("Unknown history type encountered.");
-}
+import {
+  AutoBeAnalyzeHistory,
+  AutoBeDatabaseHistory,
+  AutoBeHistory,
+  AutoBeInterfaceHistory,
+  AutoBeProcessAggregateCollection,
+  AutoBeRealizeHistory,
+  AutoBeTestHistory,
+  AutoBeUserMessageTextContent,
+  IAutoBeCompiler,
+  IAutoBeGetFilesOptions,
+} from "@autobe/interface";
+import { AutoBeProcessAggregateFactory } from "@autobe/utils";
+
+import { AutoBeState } from "../context/AutoBeState";
+import { AutoBeTokenUsage } from "../context/AutoBeTokenUsage";
+import { getAutoBeRealizeGenerated } from "./getAutoBeRealizeGenerated";
+
+/**
+ * Aggregates all generated files from the development pipeline into a complete
+ * project structure.
+ *
+ * Collects artifacts from all completed phases (Analyze, Database, Interface,
+ * Test, Realize) and assembles them into a deployable project with proper
+ * directory organization. Includes requirements documentation, database
+ * schemas, API specifications, implementation code, test suites, and benchmark
+ * reports.
+ *
+ * The phase option controls which artifacts are included, enabling incremental
+ * file generation as development progresses through the pipeline stages.
+ *
+ * @param props Configuration including compiler, current state, histories, and
+ *   options specifying target phase and database system
+ * @returns File paths mapped to complete contents for all generated artifacts
+ */
+export async function getAutoBeGenerated(props: {
+  compiler: IAutoBeCompiler;
+  state: AutoBeState;
+  histories: Readonly<AutoBeHistory[]>;
+  tokenUsage: AutoBeTokenUsage;
+  options?: Partial<IAutoBeGetFilesOptions>;
+}): Promise<Record<string, string>> {
+  const options: Required<IAutoBeGetFilesOptions> = {
+    phase:
+      (props.options?.phase ?? props.state.realize)
+        ? "realize"
+        : props.state.test
+          ? "test"
+          : props.state.interface
+            ? "interface"
+            : "analyze",
+    dbms: props.options?.dbms ?? "postgres",
+  };
+  const ret: Record<string, string> = await props.compiler.getTemplate(options);
+  ret["README.md"] = writeReadMe(props.state, ret["README.md"]);
+  if (props.state.analyze === null) return ret;
+
+  // ANALYZE
+  Object.assign<Record<string, string>, Record<string, string>>(
+    ret,
+    Object.fromEntries(
+      props.state.analyze.files.map((file) => [
+        `docs/analysis/${file.filename.split("/").at(-1)}`,
+        file.content,
+      ]),
+    ),
+  );
+  // ANALYZE - USER MESSAGES
+  const contents: AutoBeUserMessageTextContent[] = props.histories
+    .filter((h) => h.type === "userMessage")
+    .flatMap((h) => h.contents)
+    .filter((c) => c.type === "text");
+  Object.assign<Record<string, string>, Record<string, string>>(
+    ret,
+    Object.fromEntries(
+      contents.map((c, i) => [
+        `docs/user-message/user.message.${i + 1}.md`,
+        c.text,
+      ]),
+    ),
+  );
+  if (props.options?.phase === "analyze") return ret;
+
+  // PRISMA
+  if (props.state.database?.step === props.state.analyze.step) {
+    const schemaFiles: Record<string, string> =
+      await props.compiler.database.writePrismaSchemas(
+        props.state.database.result.data,
+        options!.dbms!,
+      );
+    Object.assign<
+      Record<string, string>,
+      Record<string, string>,
+      Record<string, string>
+    >(
+      ret,
+      Object.fromEntries(
+        Object.entries(schemaFiles).map(([key, value]) => [
+          `prisma/schema/${key.split("/").at(-1)}`,
+          value,
+        ]),
+      ),
+      {
+        "autobe/prisma.json": JSON.stringify(props.state.database.result.data),
+      },
+    );
+    if (props.state.database.compiled.type === "success")
+      ret["docs/ERD.md"] = props.state.database.compiled.document;
+    else if (props.state.database.compiled.type === "failure")
+      ret["prisma/compile-error-reason.log"] =
+        props.state.database.compiled.reason;
+  }
+  if (props.options?.phase === "database") return ret;
+
+  // INTERFACE
+  if (props.state.interface?.step === props.state.analyze.step) {
+    const files: Record<string, string> = await props.compiler.interface.write(
+      props.state.interface.document,
+      Object.keys(ret),
+    );
+    Object.assign<
+      Record<string, string>,
+      Record<string, string>,
+      Record<string, string>
+    >(
+      ret,
+      props.state.test?.step === props.state.interface.step
+        ? Object.fromEntries(
+            Object.entries(files).filter(
+              ([key]) => key.startsWith("test/features/") === false,
+            ),
+          )
+        : files,
+      {
+        "autobe/document.json": JSON.stringify(props.state.interface.document),
+      },
+    );
+  }
+  if (props.options?.phase === "interface") return ret;
+
+  // TEST
+  if (props.state.test?.step === props.state.analyze.step)
+    Object.assign<Record<string, string>, Record<string, string>>(
+      ret,
+      Object.fromEntries(
+        props.state.test.functions.map((f) => [f.location, f.content]),
+      ),
+    );
+
+  // REALIZE
+  if (props.state.realize?.step === props.state.analyze.step)
+    Object.assign<Record<string, string>, Record<string, string>>(
+      ret,
+      await getAutoBeRealizeGenerated({
+        compiler: props.compiler,
+        document: props.state.interface!.document,
+        authorizations: props.state.realize.authorizations,
+        functions: props.state.realize.functions,
+        options: {
+          dbms: options?.dbms ?? "postgres",
+        },
+      }),
+    );
+  if (props.options?.phase === "test") return ret;
+
+  // LOGGING
+  Object.assign<Record<string, string>, Record<string, string>>(ret, {
+    "autobe/histories.json": JSON.stringify(props.histories),
+    "autobe/tokenUsage.json": JSON.stringify(props.tokenUsage),
+  });
+  return ret;
+}
+
+function writeReadMe(state: AutoBeState, readme: string): string {
+  const emoji = (
+    history:
+      | AutoBeAnalyzeHistory
+      | AutoBeDatabaseHistory
+      | AutoBeInterfaceHistory
+      | AutoBeTestHistory
+      | AutoBeRealizeHistory
+      | null,
+  ): string => (history ? (success(history) ? "✅" : "❌") : "⬜");
+  return readme
+    .replaceAll("{{ANALYSIS_EMOJI}}", emoji(state.analyze))
+    .replaceAll("{{DATABASE_EMOJI}}", emoji(state.database))
+    .replaceAll("{{INTERFACE_EMOJI}}", emoji(state.interface))
+    .replaceAll("{{TEST_EMOJI}}", emoji(state.test))
+    .replaceAll("{{REALIZE_EMOJI}}", emoji(state.realize))
+    .replaceAll("{{BENCHMARK_AGGREGATE}}", writeBenchmarkAggregate(state))
+    .replaceAll(
+      "{{BENCHMARK_FUNCTION_CALLING}}",
+      writeBenchmarkFunctionCalling(state),
+    );
+}
+
+function writeBenchmarkAggregate(state: AutoBeState): string {
+  return (["analyze", "database", "interface", "test", "realize"] as const)
+    .map((key) => {
+      const h = state[key];
+      if (h === null) return `⬜ ${key} | | | | `;
+      return [
+        `${success(h) ? "✅" : "❌"} ${h.type}`,
+        Object.entries(label(h))
+          .map(([k, v]) => `${k}: ${v.toLocaleString()}`)
+          .join(", "),
+        (
+          (h.aggregates.total.metric.success /
+            h.aggregates.total.metric.attempt) *
+          100
+        ).toFixed(2) + " %",
+        h.aggregates.total.tokenUsage.total.toLocaleString(),
+        Math.round(
+          (new Date(h.completed_at).getTime() -
+            new Date(h.created_at).getTime()) /
+            1_000,
+        ) + " sec",
+      ].join(" | ");
+    })
+    .join("\n");
+}
+
+function writeBenchmarkFunctionCalling(state: AutoBeState): string {
+  const aggregates: AutoBeProcessAggregateCollection =
+    AutoBeProcessAggregateFactory.reduce(
+      [
+        state.analyze,
+        state.database,
+        state.interface,
+        state.test,
+        state.realize,
+      ]
+        .filter((h) => h !== null)
+        .map((h) => h.aggregates),
+    );
+  return Object.entries(aggregates)
+    .map(([key, value]) =>
+      [
+        key,
+        value.metric.attempt.toLocaleString(),
+        value.metric.validationFailure.toLocaleString(),
+        value.metric.invalidJson.toLocaleString(),
+        value.metric.success.toLocaleString(),
+        ((value.metric.success / value.metric.attempt) * 100).toFixed(2) + " %",
+      ].join(" | "),
+    )
+    .join("\n");
+}
+
+function success(
+  history:
+    | AutoBeAnalyzeHistory
+    | AutoBeDatabaseHistory
+    | AutoBeInterfaceHistory
+    | AutoBeTestHistory
+    | AutoBeRealizeHistory,
+): boolean {
+  if (history.type === "analyze") return true;
+  else if (history.type === "interface") return history.missed.length === 0;
+  else if (
+    history.type === "database" ||
+    history.type === "test" ||
+    history.type === "realize"
+  )
+    return history.compiled.type === "success";
+  history satisfies never;
+  throw new Error("Unknown history type encountered.");
+}
+
+function label(
+  history:
+    | AutoBeAnalyzeHistory
+    | AutoBeDatabaseHistory
+    | AutoBeInterfaceHistory
+    | AutoBeTestHistory
+    | AutoBeRealizeHistory,
+): Record<string, number> {
+  if (history.type === "analyze")
+    return {
+      actors: history.actors.length,
+      documents: history.files.length,
+    };
+  else if (history.type === "database")
+    return {
+      namespaces: history.result.data.files.length,
+      models: history.result.data.files.map((f) => f.models).flat().length,
+    };
+  else if (history.type === "interface")
+    return {
+      operations: history.document.operations.length,
+      schemas: Object.keys(history.document.components.schemas).length,
+    };
+  else if (history.type === "test") {
+    return {
+      functions: history.functions.length,
+      ...(history.compiled.type === "failure"
+        ? {
+            errors: new Set(
+              history.compiled.diagnostics.map((d) => d.file ?? ""),
+            ).size,
+          }
+        : {}),
+    };
+  } else if (history.type === "realize")
+    return {
+      functions: history.functions.length,
+      ...(history.compiled.type === "failure"
+        ? {
+            errors: new Set(
+              history.compiled.diagnostics.map((d) => d.file ?? ""),
+            ).size,
+          }
+        : {}),
+    };
+  history satisfies never;
+  throw new Error("Unknown history type encountered.");
+}