@autobe/agent 0.30.4 → 0.30.5

package/src/orchestrate/prisma/structures/IAutoBeDatabaseSchemaReviewApplication.ts

@@ -6,51 +6,20 @@ import { IAutoBePreliminaryGetPreviousAnalysisSections } from "../../common/stru
 import { IAutoBePreliminaryGetPreviousDatabaseSchemas } from "../../common/structures/IAutoBePreliminaryGetPreviousDatabaseSchemas";
 
 export interface IAutoBeDatabaseSchemaReviewApplication {
-  /**
-   * Process schema review task or preliminary data requests.
-   *
-   * Reviews generated database models to validate normalization, relationships,
-   * indexes, and business alignment, producing necessary modifications.
-   *
-   * @param props Request containing either preliminary data request or complete
-   *   task
-   */
+  /** Process schema review task or retrieve preliminary data. */
   process(props: IAutoBeDatabaseSchemaReviewApplication.IProps): void;
 }
 export namespace IAutoBeDatabaseSchemaReviewApplication {
   export interface IProps {
     /**
-     * Think before you act.
-     *
-     * Before requesting preliminary data or completing your task, reflect on
-     * your current state and explain your reasoning:
-     *
-     * For preliminary requests (getAnalysisSections, getDatabaseSchemas, etc.):
-     *
-     * - What critical information is missing that you don't already have?
-     * - Why do you need it specifically right now?
-     * - Be brief - state the gap, don't list everything you have.
-     *
-     * For completion (complete):
-     *
-     * - What key assets did you acquire?
-     * - What did you accomplish?
-     * - Why is it sufficient to complete?
-     * - Summarize - don't enumerate every single item.
-     *
-     * This reflection helps you avoid duplicate requests and premature
-     * completion.
+     * Reasoning about your current state: what's missing (preliminary) or what
+     * you accomplished (completion).
      */
     thinking: string;
 
     /**
-     * Type discriminator for the request.
-     *
-     * Determines which action to perform: preliminary data retrieval
-     * (getAnalysisSections, getPreviousAnalysisSections, getDatabaseSchemas,
-     * getPreviousDatabaseSchemas) or final schema review (complete). When
-     * preliminary returns empty array, that type is removed from the union,
-     * physically preventing repeated calls.
+     * Action to perform. Exhausted preliminary types are removed from the
+     * union.
      */
     request:
       | IComplete
@@ -61,77 +30,31 @@ export namespace IAutoBeDatabaseSchemaReviewApplication {
   }
 
   /**
-   * Request to review and refine database schema models.
-   *
-   * Executes comprehensive schema review to validate design quality and
-   * identify necessary improvements for normalization, relationships, and
-   * performance optimization.
+   * Review and refine database schema models for normalization, relationships,
+   * and performance.
    */
   export interface IComplete {
-    /**
-     * Type discriminator for the request.
-     *
-     * Determines which action to perform: preliminary data retrieval or actual
-     * task execution. Value "complete" indicates this is the final task
-     * execution request.
-     */
+    /** Type discriminator for completion request. */
     type: "complete";
 
     /**
-     * Comprehensive review analysis of the schema.
-     *
-     * Contains detailed evaluation of the schema design including:
-     *
-     * - Normalization validation: Confirms 3NF compliance and proper data
-     *   structure
-     * - Relationship integrity: Validates foreign key references and cardinality
-     * - Performance optimization: Reviews indexing strategy and query patterns
-     * - Business logic alignment: Ensures schema supports all use cases
-     * - Naming conventions: Verifies consistent naming patterns
-     * - Data type consistency: Confirms appropriate field types
-     * - Temporal field handling: Validates audit trail implementation
-     *
-     * The review identifies potential issues and confirms adherence to best
-     * practices before final implementation.
+     * Review analysis covering normalization, relationships, indexes, naming,
+     * and business alignment.
      */
     review: string;
 
     /**
-     * Strategic database design plan.
-     *
-     * Contains the original planning document outlining the database
-     * architecture strategy including table structures, relationships,
-     * normalization approach, and business requirement mapping. This plan
-     * serves as the blueprint for validating the implemented schema.
-     *
-     * Planning components:
-     *
-     * - Business requirements: Mapping of business needs to database structures
-     * - Table design: Entity definitions and attribute specifications
-     * - Relationship strategy: Cardinality and referential integrity planning
-     * - Normalization approach: Application of 1NF, 2NF, 3NF principles
-     * - Performance considerations: Index strategy and query optimization
-     * - Snapshot architecture: Temporal data handling and audit requirements
-     * - Materialized views: Denormalization strategy for performance
+     * Database design plan serving as the blueprint for validating the
+     * implemented schema.
      */
     plan: string;
 
     /**
-     * Corrected schema definition based on review feedback, or null if no
-     * changes are needed.
-     *
-     * When not null, the definition carries exactly one corrected
-     * {@link AutoBeDatabaseSchemaDefinition.model} for the reviewed target table
-     * so that the output stays within the LLM's maximum output token limit. If
-     * the review determines that additional child tables are required (e.g. 1NF
-     * decomposition), they are declared in
-     * {@link AutoBeDatabaseSchemaDefinition.newDesigns} as lightweight name +
-     * description pairs and will be generated by their own dedicated pipeline
-     * calls.
+     * Corrected schema definition, or null if no changes are needed.
      *
-     * If null, the original model remains unchanged from the original schema.
-     * If not null, the modification must resolve issues identified in the
-     * review.
+     * When not null, carries exactly one corrected
+     * {@link AutoBeDatabaseSchemaDefinition.model}. Additional child tables go
+     * in {@link AutoBeDatabaseSchemaDefinition.newDesigns}.
      */
     content: AutoBeDatabaseSchemaDefinition | null;
   }

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

@@ -30,6 +30,11 @@ export const transformRealizeTransformerCorrectHistory = async (
     .flat()
     .find((m) => m.name === props.function.plan.databaseSchemaName)!;
   const document: AutoBeOpenApi.IDocument = ctx.state().interface!.document;
+  const recursiveProperty: string | null =
+    AutoBeRealizeTransformerProgrammer.getRecursiveProperty({
+      schemas: document.components.schemas,
+      typeName: props.function.plan.dtoTypeName,
+    });
   const dto: Record<string, string> =
     await AutoBeRealizeTransformerProgrammer.writeStructures(
       ctx,
@@ -41,7 +46,13 @@ export const transformRealizeTransformerCorrectHistory = async (
         id: v7(),
         created_at: new Date().toISOString(),
         type: "systemMessage",
-        text: AutoBeSystemPromptConstant.REALIZE_TRANSFORMER_WRITE,
+        text:
+          recursiveProperty !== null
+            ? [
+                AutoBeSystemPromptConstant.REALIZE_TRANSFORMER_WRITE,
+                AutoBeSystemPromptConstant.REALIZE_TRANSFORMER_RECURSIVE,
+              ].join("\n\n")
+            : AutoBeSystemPromptConstant.REALIZE_TRANSFORMER_WRITE,
       },
       {
         id: v7(),
@@ -84,6 +95,14 @@ export const transformRealizeTransformerCorrectHistory = async (
           )}
           \`\`\`
 
+          Here is the **Relation Mapping Table** for model \`${props.function.plan.databaseSchemaName}\`.
+          ONLY use propertyKey values from this table in select() — NEVER guess or derive from table names:
+
+          ${AutoBeRealizeTransformerProgrammer.formatRelationMappingTable({
+            application,
+            model,
+          })}
+
           Here is the list of database schema members you have to consider
           when writing select() function:
 
@@ -127,6 +146,7 @@ export const transformRealizeTransformerCorrectHistory = async (
         schema: ctx.state().interface!.document.components.schemas[
           props.function.plan.dtoTypeName
         ] as AutoBeOpenApi.IJsonSchemaDescriptive.IObject,
+        schemas: document.components.schemas,
       })}
 
       Current code is as follows:

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

@@ -27,6 +27,15 @@ export const transformRealizeTransformerWriteHistory = async (
     .flat()
     .find((m) => m.name === props.plan.databaseSchemaName)!;
   const document: AutoBeOpenApi.IDocument = ctx.state().interface!.document;
+  const schema: AutoBeOpenApi.IJsonSchemaDescriptive.IObject = document
+    .components.schemas[
+    props.plan.dtoTypeName
+  ] as AutoBeOpenApi.IJsonSchemaDescriptive.IObject;
+  const recursiveProperty: string | null =
+    AutoBeRealizeTransformerProgrammer.getRecursiveProperty({
+      schemas: document.components.schemas,
+      typeName: props.plan.dtoTypeName,
+    });
   const dto: Record<string, string> =
     await AutoBeRealizeTransformerProgrammer.writeStructures(
       ctx,
@@ -38,7 +47,13 @@ export const transformRealizeTransformerWriteHistory = async (
         id: v7(),
         created_at: new Date().toISOString(),
         type: "systemMessage",
-        text: AutoBeSystemPromptConstant.REALIZE_TRANSFORMER_WRITE,
+        text:
+          recursiveProperty !== null
+            ? [
+                AutoBeSystemPromptConstant.REALIZE_TRANSFORMER_WRITE,
+                AutoBeSystemPromptConstant.REALIZE_TRANSFORMER_RECURSIVE,
+              ].join("\n\n")
+            : AutoBeSystemPromptConstant.REALIZE_TRANSFORMER_WRITE,
       },
       ...props.preliminary.getHistories(),
       {
@@ -65,9 +80,8 @@ export const transformRealizeTransformerWriteHistory = async (
           \`\`\`typescript
           ${AutoBeRealizeTransformerProgrammer.writeTemplate({
             plan: props.plan,
-            schema: ctx.state().interface!.document.components.schemas[
-              props.plan.dtoTypeName
-            ] as AutoBeOpenApi.IJsonSchemaDescriptive.IObject,
+            schema,
+            schemas: document.components.schemas,
           })}
           \`\`\`
 
@@ -85,6 +99,14 @@ export const transformRealizeTransformerWriteHistory = async (
             )
             .join("\n")}
 
+          Here is the **Relation Mapping Table** for model \`${props.plan.databaseSchemaName}\`.
+          ONLY use propertyKey values from this table in select() — NEVER guess or derive from table names:
+
+          ${AutoBeRealizeTransformerProgrammer.formatRelationMappingTable({
+            application,
+            model,
+          })}
+
           Here is the list of database schema members you have to consider
           when writing select() function:
 

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

@@ -20,6 +20,96 @@ import { AutoBePreliminaryController } from "../../common/AutoBePreliminaryContr
 import { compileRealizeFiles } from "../programmers/compileRealizeFiles";
 import { IAutoBeRealizeFunctionFailure } from "../structures/IAutoBeRealizeFunctionFailure";
 
+/**
+ * Deduplicate diagnostics by grouping identical messages and capping total
+ * count.
+ *
+ * Single root causes (e.g., `null` in select) can produce 50-300 cascading
+ * errors with identical messages. This function collapses them so the LLM
+ * focuses on the root cause instead of being overwhelmed by repetition.
+ */
+const deduplicateDiagnostics = (
+  diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[],
+): IAutoBeTypeScriptCompileResult.IDiagnostic[] => {
+  const byMessage = new Map<
+    string,
+    {
+      diag: IAutoBeTypeScriptCompileResult.IDiagnostic;
+      count: number;
+    }
+  >();
+  for (const d of diagnostics) {
+    const key = d.messageText;
+    const existing = byMessage.get(key);
+    if (existing) {
+      existing.count++;
+    } else {
+      byMessage.set(key, { diag: d, count: 1 });
+    }
+  }
+
+  const deduped: IAutoBeTypeScriptCompileResult.IDiagnostic[] = [];
+  for (const [, { diag, count }] of byMessage) {
+    deduped.push({
+      ...diag,
+      messageText:
+        count > 1
+          ? `${diag.messageText} (repeated ${count} times - fix the root cause)`
+          : diag.messageText,
+    });
+  }
+
+  if (deduped.length > 25) {
+    const truncated = deduped.slice(0, 25);
+    truncated.push({
+      file: deduped[0]!.file,
+      start: null,
+      length: null,
+      code: 0,
+      messageText: `[+${deduped.length - 25} additional unique errors omitted - focus on the above errors first]`,
+      category: "error",
+    });
+    return truncated;
+  }
+  return deduped;
+};
+
+/**
+ * Sanitize LLM-generated code by removing common artifacts:
+ *
+ * - Chain-of-thought text leaked into code output
+ * - Token truncation artifacts (e.g., standalone 'n' characters)
+ * - Markdown code fences
+ */
+const sanitizeGeneratedCode = (code: string): string => {
+  let result = code;
+
+  // 1. Extract code from markdown fences if present
+  const codeBlockMatch = result.match(
+    /```(?:typescript|ts)?\s*\n([\s\S]*?)\n```/,
+  );
+  if (codeBlockMatch) {
+    result = codeBlockMatch[1]!;
+  }
+
+  // 2. Remove everything before the first export statement
+  const exportMatch = result.match(
+    /(export\s+(?:namespace|async\s+function|function|const)\s+[\s\S]*)/,
+  );
+  if (exportMatch) {
+    result = exportMatch[1]!;
+  }
+
+  // 3. Remove standalone 'n' token artifacts (minimax-m2.7 pattern)
+  // Only remove lines that are EXACTLY 'n' (with optional whitespace)
+  result = result.replace(/^\s*n\s*$/gm, "");
+
+  // 4. Remove trailing 'n' after commas (another truncation pattern)
+  result = result.replace(/,\s*n\s*\n/g, ",\n");
+
+  return result.trim();
+};
+
 interface IProgrammer<
   RealizeFunction extends AutoBeRealizeFunction,
   PreliminaryKind extends AutoBePreliminaryKind,
@@ -171,6 +261,17 @@ const correct = async <
           const localFunction: RealizeFunction = props.functions.find(
             (f) => f.location === location,
           )!;
+          const rawDiagnostics = failure.diagnostics.filter(
+            (d) => d.file === localFunction.location,
+          );
+
+          // P2-5: Log when error count is very high (suggests regeneration may be better than correction)
+          if (rawDiagnostics.length > 20) {
+            console.warn(
+              `[realizeCorrectOverall] ${rawDiagnostics.length} errors in ${localFunction.location} — consider regeneration instead of correction`,
+            );
+          }
+
           const localFailures: IAutoBeRealizeFunctionFailure<RealizeFunction>[] =
             [
               ...props.previousFailures
@@ -183,9 +284,7 @@ const correct = async <
                 .filter((x) => x !== null),
               {
                 function: localFunction,
-                diagnostics: failure.diagnostics.filter(
-                  (d) => d.file === localFunction.location,
-                ),
+                diagnostics: deduplicateDiagnostics(rawDiagnostics),
               },
             ];
           try {
@@ -324,7 +423,9 @@ const process = async <
 
     const content: string = await props.programmer.replaceImportStatements({
       function: props.function,
-      code: pointer.value.revise.final ?? pointer.value.draft,
+      code: sanitizeGeneratedCode(
+        pointer.value.revise.final ?? pointer.value.draft,
+      ),
     });
     ctx.dispatch({
       id: v7(),
@@ -381,11 +482,24 @@ const compileWithFiltering = async <
   });
   if (compiled.result.type !== "failure") return compiled;
 
-  const functionLocations: string[] = props.functions.map((f) => f.location);
+  const functionLocations = new Set(props.functions.map((f) => f.location));
 
-  compiled.result.diagnostics = compiled.result.diagnostics.filter(
-    (d) => d.file !== null && functionLocations.includes(d.file),
+  const directErrors = compiled.result.diagnostics.filter(
+    (d) => d.file !== null && functionLocations.has(d.file),
+  );
+  const crossFileErrors = compiled.result.diagnostics.filter(
+    (d) => d.file !== null && !functionLocations.has(d.file),
   );
+
+  // Log cross-file errors for debugging (P1-4)
+  if (crossFileErrors.length > 0) {
+    console.warn(
+      `[realizeCorrectOverall] ${crossFileErrors.length} cross-file errors detected in: ` +
+        [...new Set(crossFileErrors.map((d) => d.file))].join(", "),
+    );
+  }
+
+  compiled.result.diagnostics = directErrors;
   if (compiled.result.diagnostics.length === 0) {
     compiled.result = { type: "success" };
   }
@@ -437,11 +551,13 @@ const separateCorrectionResults = <
   const failed: RealizeFunction[] = corrections
     .filter(
       (c) =>
-        c.type === "success" && errorLocations.includes(c.function.location),
+        (c.type === "success" &&
+          errorLocations.includes(c.function.location)) ||
+        c.type === "exception",
     )
     .map((c) => c.function);
   const ignored: RealizeFunction[] = corrections
-    .filter((c) => c.type === "ignore" || c.type === "exception")
+    .filter((c) => c.type === "ignore")
     .map((c) => c.function);
   return { success, failed, ignored };
 };

package/src/orchestrate/realize/orchestrateRealizeTransformerCorrectCasting.ts

@@ -23,6 +23,7 @@ export const orchestrateRealizeTransformerCorrectCasting = (
           schema: ctx.state().interface!.document.components.schemas[
             func.plan.dtoTypeName
           ] as AutoBeOpenApi.IJsonSchemaDescriptive.IObject,
+          schemas: ctx.state().interface!.document.components.schemas,
         }),
       replaceImportStatements: (next) =>
         AutoBeRealizeTransformerProgrammer.replaceImportStatements(ctx, {