@autobe/agent 0.24.2 → 0.25.1

package/src/orchestrate/interface/utils/JsonSchemaFactory.ts

@@ -1,8 +1,12 @@
-import { AutoBeOpenApi } from "@autobe/interface";
+import { AutoBeOpenApi, AutoBePrisma } from "@autobe/interface";
 import { AutoBeOpenApiTypeChecker, StringUtil } from "@autobe/utils";
+import { OpenApiTypeChecker } from "@samchon/openapi";
 import typia, { tags } from "typia";
 
 export namespace JsonSchemaFactory {
+  /* -----------------------------------------------------------
+    ASSIGNMENTS
+  ----------------------------------------------------------- */
   export const presets = (
     typeNames: Set<string>,
   ): Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> => {
@@ -44,6 +48,77 @@ export namespace JsonSchemaFactory {
     }
   };
 
+  export const finalize = (props: {
+    document: AutoBeOpenApi.IDocument;
+    application: AutoBePrisma.IApplication;
+  }): void => {
+    removeUnused(props.document);
+    fixTimestamps(props);
+  };
+
+  const removeUnused = (document: AutoBeOpenApi.IDocument): void => {
+    const used: Set<string> = new Set();
+    const visit = (schema: AutoBeOpenApi.IJsonSchema): void =>
+      OpenApiTypeChecker.visit({
+        components: { schemas: document.components.schemas },
+        schema,
+        closure: (next) => {
+          if (OpenApiTypeChecker.isReference(next)) {
+            const key: string = next.$ref.split("/").pop()!;
+            used.add(key);
+          }
+        },
+      });
+
+    for (const op of document.operations) {
+      if (op.requestBody !== null)
+        visit({
+          $ref: `#/components/schemas/${op.requestBody.typeName}`,
+        });
+      if (op.responseBody !== null)
+        visit({
+          $ref: `#/components/schemas/${op.responseBody.typeName}`,
+        });
+    }
+    for (const key of Object.keys(document.components.schemas))
+      if (used.has(key) === false) delete document.components.schemas[key];
+  };
+
+  const fixTimestamps = (props: {
+    document: AutoBeOpenApi.IDocument;
+    application: AutoBePrisma.IApplication;
+  }): void => {
+    const entireModels: AutoBePrisma.IModel[] = props.application.files
+      .map((f) => f.models)
+      .flat();
+    for (const value of Object.values(props.document.components.schemas)) {
+      if (AutoBeOpenApiTypeChecker.isObject(value) === false) continue;
+
+      const model: AutoBePrisma.IModel | undefined = value[
+        "x-autobe-prisma-schema"
+      ]
+        ? entireModels.find((m) => m.name === value["x-autobe-prisma-schema"])
+        : undefined;
+      if (model === undefined) continue;
+
+      const properties: string[] = Object.keys(value.properties);
+      for (const key of properties) {
+        if (
+          key !== "created_at" &&
+          key !== "updated_at" &&
+          key !== "deleted_at"
+        )
+          continue;
+        const column: AutoBePrisma.IPlainField | undefined =
+          model.plainFields.find((c) => c.name === key);
+        if (column === undefined) delete value.properties[key];
+      }
+    }
+  };
+
+  /* -----------------------------------------------------------
+    PAGINATION
+  ----------------------------------------------------------- */
   export const page = (
     key: string,
   ): AutoBeOpenApi.IJsonSchemaDescriptive.IObject => ({
@@ -69,7 +144,7 @@ export namespace JsonSchemaFactory {
     `,
   });
 
-  export const fix = (path: string, input: unknown): void => {
+  export const fixPage = (path: string, input: unknown): void => {
     if (isRecord(input) === false || isRecord(input[path]) === false) return;
 
     if (input[path].description) delete input[path].description;
@@ -99,8 +174,8 @@ export namespace JsonSchemaFactory {
 const DEFAULT_SCHEMAS = typia.assertEquals<
   Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>
 >(
-  typia.json.schemas<[IPage.IPagination, IAuthorizationToken]>().components
-    ?.schemas,
+  typia.json.schemas<[IPage.IPagination, IPage.IRequest, IAuthorizationToken]>()
+    .components?.schemas,
 );
 
 namespace IPage {
@@ -122,6 +197,19 @@ namespace IPage {
      */
     pages: number & tags.Type<"uint32">;
   }
+
+  /** Page request data */
+  export interface IRequest {
+    /** Page number. */
+    page?: null | (number & tags.Type<"uint32">);
+
+    /**
+     * Limitation of records per a page.
+     *
+     * @default 100
+     */
+    limit?: null | (number & tags.Type<"uint32">);
+  }
 }
 
 /**

package/src/orchestrate/interface/utils/JsonSchemaValidator.ts

@@ -41,7 +41,25 @@ export namespace JsonSchemaValidator {
           it to a valid variable name at the next time.
         `,
       });
-    if (props.key === "IPageIRequest")
+    if (props.key.endsWith(".IPage")) {
+      const expected: string = `IPage${props.key.substring(0, props.key.length - 6)}`;
+      props.errors.push({
+        path: `${props.path}[${JSON.stringify(props.key)}]`,
+        expected: `"IPage" must be followed by another interface name. Use ${JSON.stringify(expected)} instead.`,
+        value: props.key,
+        description: StringUtil.trim`
+          "IPage" is a reserved type name for pagination response.
+          The pagination data type name must be post-fixed after "IPage".
+          
+          However, you've defined ${JSON.stringify(props.key)}, 
+          post-fixing ".IPage" after the pagination data type name.
+
+          Change it to a valid pagination type name to be
+          ${JSON.stringify(expected)} at the next time. Note that,
+          this is not a recommendation, but an instruction you must follow.
+        `,
+      });
+    } else if (props.key === "IPageIRequest")
       props.errors.push({
         path: `${props.path}[${JSON.stringify(props.key)}]`,
         expected: `"IPageIRequest" is a mistake. Use "IPage.IRequest" instead.`,

package/src/orchestrate/interface/utils/OperationValidator.ts

@@ -1,5 +1,5 @@
 import { AutoBeOpenApi } from "@autobe/interface";
-import { AutoBeEndpointComparator, StringUtil } from "@autobe/utils";
+import { AutoBeOpenApiEndpointComparator, StringUtil } from "@autobe/utils";
 import { HashMap } from "tstl";
 import { IValidation } from "typia";
 import { Escaper } from "typia/lib/utils/Escaper";
@@ -8,14 +8,16 @@ import { emplaceMap } from "../../../utils/emplaceMap";
 import { JsonSchemaValidator } from "./JsonSchemaValidator";
 
 export namespace OperationValidator {
-  export interface IProps {
+  export const validate = (props: {
     errors: IValidation.IError[];
     path: string;
     operations: Array<
-      Omit<AutoBeOpenApi.IOperation, "authorizationRole" | "authorizationType">
+      Omit<
+        AutoBeOpenApi.IOperation,
+        "authorizationRole" | "authorizationType" | "prerequisites"
+      >
     >;
-  }
-  export const validate = (props: IProps): void => {
+  }): void => {
     props.operations.forEach((op, i) => {
       // get method has request body
       if (op.method === "get" && op.requestBody !== null)
@@ -59,8 +61,8 @@ export namespace OperationValidator {
 
     // validate duplicated endpoints
     const endpoints: HashMap<AutoBeOpenApi.IEndpoint, number[]> = new HashMap(
-      AutoBeEndpointComparator.hashCode,
-      AutoBeEndpointComparator.equals,
+      AutoBeOpenApiEndpointComparator.hashCode,
+      AutoBeOpenApiEndpointComparator.equals,
     );
     props.operations.forEach((op, i) => {
       const key: AutoBeOpenApi.IEndpoint = {

package/src/orchestrate/prisma/histories/transformPrismaComponentsHistories.ts

@@ -8,14 +8,17 @@ import { AutoBeState } from "../../../context/AutoBeState";
 
 export const transformPrismaComponentsHistories = (
   state: AutoBeState,
-  prefix: string | null = null,
+  props: {
+    prefix: string | null;
+    instruction: string;
+  },
 ): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
 > => {
   if (state.analyze === null)
     // unreachable
     throw new Error("Analyze state is not set.");
-  if (prefix) prefix = NamingConvention.snake(prefix);
+  if (props.prefix) props.prefix = NamingConvention.snake(props.prefix);
   return [
     {
       id: v7(),
@@ -28,20 +31,20 @@ export const transformPrismaComponentsHistories = (
       created_at: new Date().toISOString(),
       type: "assistantMessage",
       text: StringUtil.trim`
+        ## Requirement Analysis Report
+
         Here is the requirement analysis report.
         
         Call the provided tool function to generate Prisma DB schema
         referencing below requirement analysis report.
         
-        ## Requirement Analysis Report
-        
         \`\`\`json
         ${JSON.stringify(state.analyze.files)}
         \`\`\`
         
         ## Prefix
         
-        - Prefix provided by the user: ${prefix}
+        - Prefix provided by the user: ${props.prefix}
         
         The user wants all database schema (table) names to start with the prefix provided below.
         
@@ -74,11 +77,22 @@ export const transformPrismaComponentsHistories = (
                 Create separate tables for each role:
                 
                 ${state.analyze.roles
-                  .map((role) => `- ${prefix}_${role.name.toLowerCase()}`)
+                  .map((role) => `- ${props.prefix}_${role.name.toLowerCase()}`)
                   .join("\n")}
               `
             : ""
         }
+
+        ## Database Design Instructions
+
+        The following database-specific instructions were extracted by AI from
+        the user's utterances. These focus ONLY on database schema design aspects
+        such as table structure, relationships, constraints, and indexing strategies.
+
+        Reference these instructions when designing namespace components and 
+        DB table names.
+
+        ${props.instruction}
       `,
     },
   ];

package/src/orchestrate/prisma/histories/transformPrismaSchemaHistories.ts

@@ -5,11 +5,12 @@ import { v7 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
 
-export const transformPrismaSchemaHistories = (
-  requirementAnalysisReport: Record<string, string>,
-  targetComponent: AutoBePrisma.IComponent,
-  otherTables: string[],
-): Array<
+export const transformPrismaSchemaHistories = (props: {
+  analysis: Record<string, string>;
+  targetComponent: AutoBePrisma.IComponent;
+  otherTables: string[];
+  instruction: string;
+}): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
 > => {
   return [
@@ -27,7 +28,7 @@ export const transformPrismaSchemaHistories = (
         Here is the requirement analysis report:
 
         \`\`\`json
-        ${JSON.stringify(requirementAnalysisReport)}
+        ${JSON.stringify(props.analysis)}
         \`\`\`
       `,
     },
@@ -36,12 +37,26 @@ export const transformPrismaSchemaHistories = (
       created_at: new Date().toISOString(),
       type: "assistantMessage",
       text: StringUtil.trim`
+        ## Database Design Instructions
+
+        The following database-specific instructions were extracted by AI from
+        the user's utterances. These focus ONLY on database schema design aspects
+        such as table structure, relationships, constraints, and indexing strategies.
+
+        Reference these instructions when designing the DB schema for this specific
+        component. If the instruction is not related to the current domain or
+        component, you may ignore it.
+
+        ${props.instruction}
+
+        ## Target Component
+        
         Here is the input data for generating Prisma DB schema.
         
         \`\`\`json
         ${JSON.stringify({
-          targetComponent,
-          otherTables,
+          targetComponent: props.targetComponent,
+          otherTables: props.otherTables,
         })}
         \`\`\`
       `,
@@ -58,7 +73,7 @@ export const transformPrismaSchemaHistories = (
         
         \`\`\`json
         ${JSON.stringify({
-          targetComponent,
+          targetComponent: props.targetComponent,
         })}
         \`\`\`
       `,

package/src/orchestrate/prisma/orchestratePrisma.ts

@@ -39,18 +39,22 @@ export const orchestratePrisma = async <Model extends ILlmSchema.Model>(
     type: "prismaStart",
     id: v7(),
     created_at: start.toISOString(),
-    reason: props.reason,
+    reason: props.instruction,
     step: ctx.state().analyze?.step ?? 0,
   });
 
   // COMPONENTS
   const componentEvent: AutoBePrismaComponentsEvent =
-    await orchestratePrismaComponents(ctx);
+    await orchestratePrismaComponents(ctx, props.instruction);
   ctx.dispatch(componentEvent);
 
   // CONSTRUCT AST DATA
   const schemaEvents: AutoBePrismaSchemasEvent[] =
-    await orchestratePrismaSchemas(ctx, componentEvent.components);
+    await orchestratePrismaSchemas(
+      ctx,
+      props.instruction,
+      componentEvent.components,
+    );
   const application: AutoBePrisma.IApplication = {
     files: schemaEvents.map((e) => e.file),
   };

package/src/orchestrate/prisma/orchestratePrismaComponent.ts

@@ -14,6 +14,7 @@ export async function orchestratePrismaComponents<
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
+  instruction: string,
   message: string = "Design database from the given requirement analysis documents.",
 ): Promise<AutoBePrismaComponentsEvent> {
   const start: Date = new Date();
@@ -23,7 +24,10 @@ export async function orchestratePrismaComponents<
   const prefix: string | null = ctx.state().analyze?.prefix ?? null;
   const { tokenUsage } = await ctx.conversate({
     source: "prismaComponents",
-    histories: transformPrismaComponentsHistories(ctx.state(), prefix),
+    histories: transformPrismaComponentsHistories(ctx.state(), {
+      prefix,
+      instruction,
+    }),
     controller: createController({
       model: ctx.model,
       build: (next) => {

package/src/orchestrate/prisma/orchestratePrismaSchemas.ts

@@ -15,6 +15,7 @@ import { IAutoBePrismaSchemaApplication } from "./structures/IAutoBePrismaSchema
 
 export async function orchestratePrismaSchemas<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
+  instruction: string,
   componentList: AutoBePrisma.IComponent[],
 ): Promise<AutoBePrismaSchemasEvent[]> {
   const start: Date = new Date();
@@ -29,6 +30,7 @@ export async function orchestratePrismaSchemas<Model extends ILlmSchema.Model>(
         .map((c) => c.tables)
         .flat();
       const event: AutoBePrismaSchemasEvent = await process(ctx, {
+        instruction,
         component,
         otherTables,
         start,
@@ -45,6 +47,7 @@ export async function orchestratePrismaSchemas<Model extends ILlmSchema.Model>(
 async function process<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   props: {
+    instruction: string;
     component: AutoBePrisma.IComponent;
     otherTables: string[];
     start: Date;
@@ -58,16 +61,18 @@ async function process<Model extends ILlmSchema.Model>(
   };
   const { tokenUsage } = await ctx.conversate({
     source: "prismaSchemas",
-    histories: transformPrismaSchemaHistories(
-      ctx
-        .state()
-        .analyze?.files.map((file) => ({ [file.filename]: file.content }))
-        .reduce((acc, cur) => {
-          return Object.assign(acc, cur);
-        }, {}) ?? {},
-      props.component,
-      props.otherTables,
-    ),
+    histories: transformPrismaSchemaHistories({
+      analysis:
+        ctx
+          .state()
+          .analyze?.files.map((file) => ({ [file.filename]: file.content }))
+          .reduce((acc, cur) => {
+            return Object.assign(acc, cur);
+          }, {}) ?? {},
+      targetComponent: props.component,
+      otherTables: props.otherTables,
+      instruction: props.instruction,
+    }),
     controller: createController(ctx, {
       targetComponent: props.component,
       otherTables: props.otherTables,

package/src/orchestrate/realize/histories/transformRealizeCorrectCastingHistories.ts

@@ -0,0 +1,44 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { IAutoBeTypeScriptCompileResult } from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+import { v7 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { printErrorHints } from "../utils/printErrorHints";
+
+interface IFailure {
+  diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[];
+  script: string;
+}
+
+export const transformRealizeCorrectCastingHistories = (
+  failures: IFailure[],
+): Array<
+  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+> => {
+  return [
+    {
+      id: v7(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.COMMON_CORRECT_CASTING,
+    },
+    ...failures.map(
+      (f) =>
+        ({
+          id: v7(),
+          created_at: new Date().toISOString(),
+          type: "assistantMessage",
+          text: StringUtil.trim`
+          # Errors
+
+          This is a past code and an error with the code. 
+          Please refer to the annotation for the location of the error.
+
+          ${printErrorHints(f.script, f.diagnostics)}          
+          \`\`\`
+        `,
+        }) satisfies IAgenticaHistoryJson.IAssistantMessage,
+    ),
+  ];
+};

package/src/orchestrate/realize/histories/transformRealizeCorrectHistories.ts

@@ -7,6 +7,7 @@ import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromp
 import { AutoBeState } from "../../../context/AutoBeState";
 import { IAutoBeRealizeFunctionFailure } from "../structures/IAutoBeRealizeFunctionFailure";
 import { IAutoBeRealizeScenarioResult } from "../structures/IAutoBeRealizeScenarioResult";
+import { printErrorHints } from "../utils/printErrorHints";
 import { transformRealizeWriteHistories } from "./transformRealizeWriteHistories";
 
 export function transformRealizeCorrectHistories(props: {
@@ -40,30 +41,18 @@ export function transformRealizeCorrectHistories(props: {
       `,
       created_at: new Date().toISOString(),
     },
-    ...props.failures.map(
-      (f) =>
-        ({
-          id: v7(),
-          type: "assistantMessage",
-          text: StringUtil.trim`
-
-      ## Generated Typescript Code
-
-      \`\`\`typescript
-      ${f.function.content}
-      \`\`\`
-
-      ## Compile Errors
-
-      Fix the comilation error in the provided code.
-
-      \`\`\`typescript
-      ${JSON.stringify(f.diagnostics)}
-      \`\`\`
-      `,
-          created_at: new Date().toISOString(),
-        }) satisfies IAgenticaHistoryJson.IAssistantMessage,
-    ),
+    ...props.failures.map((f) => {
+      return {
+        id: v7(),
+        type: "assistantMessage",
+        text: StringUtil.trim`
+            This is a past code and an error with the code. Please refer to the annotation for the location of the error.
+
+            ${printErrorHints(f.function.content, f.diagnostics)}
+          `,
+        created_at: new Date().toISOString(),
+      } satisfies IAgenticaHistoryJson.IAssistantMessage;
+    }),
     {
       id: v7(),
       type: "systemMessage",

package/src/orchestrate/realize/histories/transformRealizeWriteAuthorizationsHistories.ts

@@ -29,13 +29,13 @@ export const transformRealizeWriteAuthorizationsHistories = (
               - Must NOT require authentication decorator (this endpoint creates authentication)
               - Should check if user exists and password matches
 
-              ### MANDATORY: Use MyGlobal.password for Password Verification
+              ### MANDATORY: Use PasswordUtil for Password Verification
               
-              **CRITICAL**: You MUST use MyGlobal.password utilities for password verification to ensure consistency with the join operation:
+              **CRITICAL**: You MUST use PasswordUtil utilities for password verification to ensure consistency with the join operation:
 
               \`\`\`typescript
               // Example: Password verification in login
-              const isValid = await MyGlobal.password.verify(
+              const isValid = await PasswordUtil.verify(
                 body.password,           // plain password from request
                 user.password_hash       // hashed password from database
               );
@@ -126,13 +126,13 @@ export const transformRealizeWriteAuthorizationsHistories = (
               - Should create a new user record in the database
               - Must NOT require authentication decorator (public endpoint)
 
-              ### MANDATORY: Use MyGlobal.password for Password Hashing
+              ### MANDATORY: Use PasswordUtil for Password Hashing
               
-              **CRITICAL**: You MUST use MyGlobal.password utilities for password hashing to ensure consistency across all authentication operations:
+              **CRITICAL**: You MUST use PasswordUtil utilities for password hashing to ensure consistency across all authentication operations:
 
               \`\`\`typescript
               // Example: Password hashing in join/registration
-              const hashedPassword = await MyGlobal.password.hash(body.password);
+              const hashedPassword = await PasswordUtil.hash(body.password);
               
               // Store the hashed password in database
               await MyGlobal.prisma.users.create({

package/src/orchestrate/realize/histories/transformRealizeWriteHistories.ts

@@ -100,6 +100,7 @@ export const transformRealizeWriteHistories = (props: {
   const authorizationHistories = operation.authorizationType
     ? transformRealizeWriteAuthorizationsHistories(operation, payloads)
     : [];
+  const document = props.state.interface.document;
 
   return [
     {
@@ -127,11 +128,12 @@ export const transformRealizeWriteHistories = (props: {
       id: v7(),
       type: "systemMessage",
       created_at: new Date().toISOString(),
-      text: getRealizeWriteCodeTemplate(
-        props.scenario,
+      text: getRealizeWriteCodeTemplate({
+        authorization: props.authorization,
+        scenario: props.scenario,
+        schemas: document.components.schemas,
         operation,
-        props.authorization,
-      ),
+      }),
     },
     {
       id: v7(),

package/src/orchestrate/realize/internal/compileRealizeFiles.ts

@@ -47,13 +47,11 @@ export async function compileRealizeFiles<Model extends ILlmSchema.Model>(
       props.functions.map((el) => [el.location, el.content]),
     ),
   };
-
   const compiled: IAutoBeTypeScriptCompileResult =
     await compiler.typescript.compile({
       files: files,
     });
-
-  const event: AutoBeRealizeValidateEvent = {
+  return {
     type: "realizeValidate",
     id: v7(),
     files: files,
@@ -61,6 +59,4 @@ export async function compileRealizeFiles<Model extends ILlmSchema.Model>(
     step: ctx.state().analyze?.step ?? 0,
     created_at: new Date().toISOString(),
   };
-
-  return event;
 }