@autobe/agent 0.10.6 → 0.11.1

package/src/orchestrate/test/orchestrateTestCorrect.ts

@@ -1,6 +1,7 @@
 import { IAgenticaController, MicroAgentica } from "@agentica/core";
 import {
   AutoBeTestValidateEvent,
+  IAutoBeCompiler,
   IAutoBeTypeScriptCompileResult,
 } from "@autobe/interface";
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
@@ -51,14 +52,14 @@ const compile = async <Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   func: IAutoBeTestFunction,
 ): Promise<AutoBeTestValidateEvent> => {
-  const compiled: IAutoBeTypeScriptCompileResult =
-    await ctx.compiler.test.compile({
-      files: {
-        ...func.artifacts.dto,
-        ...func.artifacts.sdk,
-        [func.location]: func.script,
-      },
-    });
+  const compiler: IAutoBeCompiler = await ctx.compiler();
+  const result: IAutoBeTypeScriptCompileResult = await compiler.test.compile({
+    files: {
+      ...func.artifacts.dto,
+      ...func.artifacts.sdk,
+      [func.location]: func.script,
+    },
+  });
   return {
     type: "testValidate",
     file: {
@@ -66,7 +67,7 @@ const compile = async <Model extends ILlmSchema.Model>(
       location: func.location,
       content: func.script,
     },
-    result: compiled,
+    result,
     created_at: new Date().toISOString(),
     step: ctx.state().analyze?.step ?? 0,
   };

package/src/orchestrate/test/orchestrateTestWrite.ts

@@ -22,39 +22,45 @@ export async function orchestrateTestWrite<Model extends ILlmSchema.Model>(
   const start: Date = new Date();
   let complete: number = 0;
 
-  return Promise.all(
+  const result = await Promise.all(
     /**
      * Generate test code for each scenario. Maps through plans array to create
      * individual test code implementations. Each scenario is processed to
      * generate corresponding test code and progress events.
      */
-    scenarios.map((scenario) =>
-      forceRetry(async () => {
-        const artifacts: IAutoBeTestScenarioArtifacts =
-          await getTestScenarioArtifacts(ctx, scenario);
-        const result: IAutoBeTestWriteApplication.IProps = await process(
-          ctx,
-          scenario,
-          artifacts,
-        );
-        const event: AutoBeTestWriteEvent = {
-          type: "testWrite",
-          created_at: start.toISOString(),
-          location: `test/features/api/${result.domain}/${scenario.functionName}.ts`,
-          ...result,
-          completed: ++complete,
-          total: scenarios.length,
-          step: ctx.state().interface?.step ?? 0,
-        };
-        ctx.dispatch(event);
-        return {
-          scenario,
-          artifacts,
-          event,
-        };
-      }),
-    ),
+    scenarios.map(async (scenario) => {
+      try {
+        const r = await forceRetry(async () => {
+          const artifacts: IAutoBeTestScenarioArtifacts =
+            await getTestScenarioArtifacts(ctx, scenario);
+          const result: IAutoBeTestWriteApplication.IProps = await process(
+            ctx,
+            scenario,
+            artifacts,
+          );
+          const event: AutoBeTestWriteEvent = {
+            type: "testWrite",
+            created_at: start.toISOString(),
+            location: `test/features/api/${result.domain}/${scenario.functionName}.ts`,
+            ...result,
+            completed: ++complete,
+            total: scenarios.length,
+            step: ctx.state().interface?.step ?? 0,
+          };
+          ctx.dispatch(event);
+          return {
+            scenario,
+            artifacts,
+            event,
+          };
+        });
+        return r;
+      } catch {
+        return null;
+      }
+    }),
   );
+  return result.filter((r) => r !== null);
 }
 
 /**

package/src/structures/IAutoBeProps.ts

@@ -1,6 +1,7 @@
 import {
   AutoBeHistory,
   IAutoBeCompiler,
+  IAutoBeCompilerListener,
   IAutoBeTokenUsageJson,
 } from "@autobe/interface";
 import { ILlmSchema } from "@samchon/openapi";
@@ -64,19 +65,21 @@ export interface IAutoBeProps<Model extends ILlmSchema.Model> {
   vendor: IAutoBeVendor;
 
   /**
-   * Compilation infrastructure for TypeScript, Prisma, and OpenAPI operations.
+   * Compiler factory function for TypeScript, Prisma, and OpenAPI operations.
    *
-   * Provides the essential compilation tools required for the sophisticated
-   * AST-based development pipeline. The compiler handles validation,
-   * transformation, and code generation across all development phases including
-   * Prisma schema compilation, OpenAPI document validation, and TypeScript code
-   * compilation.
+   * Factory function that creates compiler instances required for the
+   * sophisticated AST-based development pipeline. The compiler handles
+   * validation, transformation, and code generation across all development
+   * phases including Prisma schema compilation, OpenAPI document validation,
+   * and TypeScript code compilation.
    *
    * For high-performance scenarios with multiple concurrent users, the compiler
    * can be separated into dedicated worker processes to prevent blocking the
    * main agent during computationally intensive compilation operations.
    */
-  compiler: IAutoBeCompiler;
+  compiler: (
+    listener: IAutoBeCompilerListener,
+  ) => IAutoBeCompiler | Promise<IAutoBeCompiler>;
 
   /**
    * Optional conversation and development histories for session continuation.

package/src/utils/pipe.ts

@@ -0,0 +1,39 @@
+import { FAILED } from "../orchestrate/realize/structures/IAutoBeRealizeFailedSymbol";
+
+export function pipe<A, B>(
+  a: A,
+  ab: (a: A) => Promise<B | FAILED>,
+): Promise<B | FAILED>;
+
+export function pipe<A, B, C>(
+  a: A,
+  ab: (a: A) => Promise<B | FAILED>,
+  bc: (b: B) => Promise<C | FAILED>,
+): Promise<C | FAILED>;
+
+export function pipe<A, B, C, D>(
+  a: A,
+  ab: (a: A) => Promise<B | FAILED>,
+  bc: (b: B) => Promise<C | FAILED>,
+  cd: (c: C) => Promise<D | FAILED>,
+): Promise<D | FAILED>;
+
+export function pipe<A, B, C, D, E>(
+  a: A,
+  ab: (a: A) => Promise<B | FAILED>,
+  bc: (b: B) => Promise<C | FAILED>,
+  cd: (c: C) => Promise<D | FAILED>,
+  de: (d: D) => Promise<E | FAILED>,
+): Promise<E | FAILED>;
+
+export function pipe(
+  a: any,
+  ...fns: Array<(arg: any) => Promise<any>>
+): Promise<any> {
+  return fns.reduce((prev, fn) => {
+    return prev.then((result) => {
+      if (result === FAILED) return FAILED;
+      return fn(result);
+    });
+  }, Promise.resolve(a));
+}

package/lib/orchestrate/analyze/AutoBeAnalyzeAgent.d.ts

@@ -1,20 +0,0 @@
-import { ILlmSchema } from "@samchon/openapi";
-import { AutoBeContext } from "../../context/AutoBeContext";
-import { AutoBeAnalyzePointer } from "./AutoBeAnalyzePointer";
-import { AutoBeAnalyzeReviewer } from "./AutoBeAnalyzeReviewer";
-export declare class AutoBeAnalyzeAgent<Model extends ILlmSchema.Model> {
-    private readonly createReviewerAgentFn;
-    private readonly ctx;
-    private readonly pointer;
-    private readonly filenames;
-    private readonly createAnalyzeAgent;
-    private readonly fileMap;
-    constructor(createReviewerAgentFn: typeof AutoBeAnalyzeReviewer, ctx: AutoBeContext<Model>, pointer: AutoBeAnalyzePointer, filenames: string[]);
-    /**
-     * Conversate with planner agent
-     *
-     * @param content Conversation from user in this time.
-     * @returns
-     */
-    conversate(content: string, retry?: number): Promise<string>;
-}