@autobe/agent 0.30.1 → 0.30.3

package/src/orchestrate/analyze/histories/transformAnalyzeExtractDecisionsHistory.ts

@@ -0,0 +1,69 @@
+import {
+  AutoBeAnalyze,
+  AutoBeAnalyzeWriteSectionEvent,
+} from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+import { v7 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+import { AutoBeContext } from "../../../context/AutoBeContext";
+import { IAutoBeOrchestrateHistory } from "../../../structures/IAutoBeOrchestrateHistory";
+
+/**
+ * Transform histories for key decision extraction from a single file.
+ *
+ * Provides the extractor with:
+ *
+ * 1. The system prompt for decision extraction
+ * 2. The full section content of ONE file
+ *
+ * Each file is processed independently in parallel, so only one file's content
+ * is included per call.
+ */
+export const transformAnalyzeExtractDecisionsHistory = (
+  _ctx: AutoBeContext,
+  props: {
+    file: AutoBeAnalyze.IFileScenario;
+    sectionEvents: AutoBeAnalyzeWriteSectionEvent[][];
+  },
+): IAutoBeOrchestrateHistory => {
+  // Build full section content for this file
+  const fileContent = props.sectionEvents
+    .map((sectionsForModule, moduleIndex) =>
+      sectionsForModule
+        .map((sectionEvent, unitIndex) =>
+          sectionEvent.sectionSections
+            .map(
+              (section) =>
+                `### [M${moduleIndex + 1}.U${unitIndex + 1}] ${section.title}\n\n${section.content}`,
+            )
+            .join("\n\n"),
+        )
+        .join("\n\n"),
+    )
+    .join("\n\n---\n\n");
+
+  return {
+    histories: [
+      {
+        id: v7(),
+        created_at: new Date().toISOString(),
+        type: "systemMessage",
+        text: AutoBeSystemPromptConstant.ANALYZE_EXTRACT_DECISIONS,
+      },
+      {
+        id: v7(),
+        created_at: new Date().toISOString(),
+        type: "assistantMessage",
+        text: StringUtil.trim`
+          ## File: ${props.file.filename}
+
+          ## Full Section Content
+
+          ${fileContent}
+        `,
+      },
+    ],
+    userMessage: `Extract all binary and discrete decisions from the file "${props.file.filename}". Return structured decisions for cross-file contradiction detection.`,
+  };
+};

package/src/orchestrate/analyze/histories/transformAnalyzeSectionCrossFileReviewHistory.ts

@@ -33,6 +33,7 @@ export const transformAnalyzeSectionCrossFileReviewHistory = (
       status: "approved" | "rewritten" | "new";
     }>;
     mechanicalViolationSummary?: string;
+    fileDecisions?: import("../utils/detectDecisionConflicts").IFileDecisions[];
     preliminary: null | AutoBePreliminaryController<"previousAnalysisSections">;
   },
 ): IAutoBeOrchestrateHistory => {
@@ -115,6 +116,25 @@ export const transformAnalyzeSectionCrossFileReviewHistory = (
             : ""
         }
 
+        ${
+          props.fileDecisions && props.fileDecisions.length > 0
+            ? `
+        ## Extracted Key Decisions Per File
+
+        Below are the key behavioral decisions extracted from each file.
+        Use these to verify cross-file consistency — same topic+decision should have the same value across files.
+
+        ${props.fileDecisions
+          .filter((fd) => fd.decisions.length > 0)
+          .map(
+            (fd) =>
+              `**${fd.filename}**:\n${fd.decisions.map((d) => `- ${d.topic}.${d.decision} = "${d.value}" — ${d.evidence.slice(0, 100)}`).join("\n")}`,
+          )
+          .join("\n\n")}
+        `
+            : ""
+        }
+
         ## Cross-File Semantic Consistency Criteria
 
         Focus ONLY on issues requiring human-like judgment:

package/src/orchestrate/analyze/orchestrateAnalyze.ts

@@ -22,6 +22,7 @@ import { AutoBePreliminaryExhaustedError } from "../../utils/AutoBePreliminaryEx
 import { AutoBeTimeoutError } from "../../utils/AutoBeTimeoutError";
 import { executeCachedBatch } from "../../utils/executeCachedBatch";
 import { fillTocDeterministic } from "./fillTocDeterministic";
+import { orchestrateAnalyzeExtractDecisions } from "./orchestrateAnalyzeExtractDecisions";
 import { orchestrateAnalyzeScenario } from "./orchestrateAnalyzeScenario";
 import { orchestrateAnalyzeScenarioReview } from "./orchestrateAnalyzeScenarioReview";
 import { orchestrateAnalyzeSectionCrossFileReview } from "./orchestrateAnalyzeSectionCrossFileReview";
@@ -56,6 +57,11 @@ import {
   detectErrorCodeConflicts,
 } from "./utils/buildErrorCodeRegistry";
 import { detectOversizedToc } from "./utils/buildHardValidators";
+import {
+  IFileDecisions,
+  buildFileDecisionConflictMap,
+  detectDecisionConflicts,
+} from "./utils/detectDecisionConflicts";
 import {
   buildFileProseConflictMap,
   detectProseConstraintConflicts,
@@ -836,6 +842,39 @@ async function processStageSection(
         sectionEvents: state.sectionResults!,
       }));
 
+    // Pass 2a-pre: LLM-based key decision extraction (parallel per file)
+    analyzeDebug(`section decision-extraction-start attempt=${attempt}`);
+    const fileDecisions: IFileDecisions[] = await Promise.all(
+      filesWithSections
+        .filter(({ file }) => file.filename !== "00-toc.md")
+        .map(({ file, sectionEvents }) =>
+          orchestrateAnalyzeExtractDecisions(ctx, {
+            file,
+            sectionEvents,
+          }).catch((e) => {
+            analyzeDebug(
+              `section decision-extraction-error file="${file.filename}" error=${(e as Error).message}`,
+            );
+            return { filename: file.filename, decisions: [] } as IFileDecisions;
+          }),
+        ),
+    );
+    analyzeDebug(
+      `section decision-extraction-done attempt=${attempt} files=${fileDecisions.length} totalDecisions=${fileDecisions.reduce((sum, fd) => sum + fd.decisions.length, 0)}`,
+    );
+
+    // Pass 2a-pre2: Programmatic decision conflict detection
+    const decisionConflicts = detectDecisionConflicts({
+      fileDecisions,
+    });
+    const fileDecisionConflictMap: Map<string, string[]> =
+      buildFileDecisionConflictMap(decisionConflicts);
+    if (decisionConflicts.length > 0) {
+      analyzeDebug(
+        `section decision-conflicts-found count=${decisionConflicts.length}: ${decisionConflicts.map((c) => `${c.topic}.${c.decision}`).join(", ")}`,
+      );
+    }
+
     // Pass 2a: Programmatic cross-file validation (BEFORE LLM review)
     const criticalConflicts = detectConstraintConflicts({
       files: filesWithSections,
@@ -911,6 +950,10 @@ async function processStageSection(
         (c) =>
           `Prose constraint conflict: ${c.entityAttr} — canonical [${c.canonicalValues.join(", ")}] vs prose [${c.proseValues.join(", ")}] in ${c.file}`,
       ),
+      ...decisionConflicts.map(
+        (c) =>
+          `Decision conflict: ${c.topic}.${c.decision} — ${c.values.map((v) => `"${v.value}" in [${v.files.join(", ")}]`).join(" vs ")}`,
+      ),
     ];
     const mechanicalViolationSummary =
       allMechanicalViolations.length > 0
@@ -942,6 +985,7 @@ async function processStageSection(
               };
             }),
           mechanicalViolationSummary,
+          fileDecisions,
           progress: props.crossFileSectionReviewProgress,
           promptCacheKey,
           retry: attempt,
@@ -1011,6 +1055,7 @@ async function processStageSection(
         fileErrorCodeConflictMap.get(filename) ?? [];
       const fileOversizedToc = oversizedTocMap.get(fileIndex) ?? [];
       const fileProseConflicts = fileProseConflictMap.get(filename) ?? [];
+      const fileDecisionConflicts = fileDecisionConflictMap.get(filename) ?? [];
       const hasCriticalConflict =
         fileCriticalConflicts.length > 0 ||
         fileAttrDuplicates.length > 0 ||
@@ -1019,7 +1064,8 @@ async function processStageSection(
         fileStateFieldConflicts.length > 0 ||
         fileErrorCodeConflicts.length > 0 ||
         fileOversizedToc.length > 0 ||
-        fileProseConflicts.length > 0;
+        fileProseConflicts.length > 0 ||
+        fileDecisionConflicts.length > 0;
 
       // Decision logic:
       // 1. per-file reject → reject (unchanged)
@@ -1040,6 +1086,7 @@ async function processStageSection(
         fileErrorCodeConflicts,
         fileOversizedToc,
         fileProseConflicts,
+        fileDecisionConflicts,
       });
 
       if (approved) {
@@ -1091,6 +1138,7 @@ async function processStageSection(
               ...fileAttrDuplicates,
               ...fileEnumConflicts,
               ...fileProseConflicts,
+              ...fileDecisionConflicts,
             ].join("; ")}` +
             (crossFileResult?.feedback ? `\n${crossFileResult.feedback}` : ""),
           issues: [...programmaticIssues, ...structuredCrossFileIssues],
@@ -1316,6 +1364,7 @@ function buildProgrammaticSectionIssues(props: {
   fileErrorCodeConflicts: string[];
   fileOversizedToc: string[];
   fileProseConflicts: string[];
+  fileDecisionConflicts: string[];
 }): AutoBeAnalyzeSectionReviewIssue[] {
   return [
     ...props.fileCriticalConflicts.map((detail) => ({
@@ -1382,6 +1431,14 @@ function buildProgrammaticSectionIssues(props: {
         "Remove the restated constraint value and use a backtick reference to the canonical definition in 02-domain-model instead. Example: 'THE system SHALL validate `User.bio` per entity constraints (see 02-domain-model)'",
       evidence: detail,
     })),
+    ...props.fileDecisionConflicts.map((detail) => ({
+      ruleCode: "cross_file_decision_conflict",
+      moduleIndex: null,
+      unitIndex: null,
+      fixInstruction:
+        "This file contradicts another file on a key behavioral decision. Align with the canonical source file for this topic.",
+      evidence: detail,
+    })),
   ];
 }
 

package/src/orchestrate/analyze/orchestrateAnalyzeExtractDecisions.ts

@@ -0,0 +1,97 @@
+import { IAgenticaController } from "@agentica/core";
+import {
+  AutoBeAnalyze,
+  AutoBeAnalyzeWriteSectionEvent,
+  AutoBeEventSource,
+} from "@autobe/interface";
+import { IPointer } from "tstl";
+import typia, { ILlmApplication, IValidation } from "typia";
+
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { transformAnalyzeExtractDecisionsHistory } from "./histories/transformAnalyzeExtractDecisionsHistory";
+import {
+  IAutoBeAnalyzeExtractDecisionsApplication,
+  IAutoBeAnalyzeExtractDecisionsApplicationComplete,
+  IAutoBeAnalyzeExtractDecisionsApplicationProps,
+} from "./structures/IAutoBeAnalyzeExtractDecisionsApplication";
+import { IFileDecisions } from "./utils/detectDecisionConflicts";
+import { isRecord, tryParseStringAsRecord } from "./utils/repairUtils";
+
+/**
+ * Extract key decisions from a single file's section content.
+ *
+ * This orchestrator calls the LLM to read one file's full section content and
+ * extract binary/discrete decisions as structured data. The extracted decisions
+ * are then used for programmatic cross-file contradiction detection.
+ *
+ * Called in parallel for each file (excluding 00-toc.md) after per-file review
+ * approves.
+ */
+export const orchestrateAnalyzeExtractDecisions = async (
+  ctx: AutoBeContext,
+  props: {
+    file: AutoBeAnalyze.IFileScenario;
+    sectionEvents: AutoBeAnalyzeWriteSectionEvent[][];
+  },
+): Promise<IFileDecisions> => {
+  const pointer: IPointer<IAutoBeAnalyzeExtractDecisionsApplicationComplete | null> =
+    {
+      value: null,
+    };
+
+  await ctx.conversate({
+    source: SOURCE,
+    controller: createController({ pointer }),
+    enforceFunctionCall: true,
+    ...transformAnalyzeExtractDecisionsHistory(ctx, {
+      file: props.file,
+      sectionEvents: props.sectionEvents,
+    }),
+  });
+
+  return {
+    filename: props.file.filename,
+    decisions: (pointer.value?.decisions ?? []).map((d) => ({
+      topic: d.topic,
+      decision: d.decision,
+      value: d.value,
+      evidence: d.evidence,
+    })),
+  };
+};
+
+function createController(props: {
+  pointer: IPointer<IAutoBeAnalyzeExtractDecisionsApplicationComplete | null>;
+}): IAgenticaController.IClass {
+  const application: ILlmApplication =
+    typia.llm.application<IAutoBeAnalyzeExtractDecisionsApplication>({
+      validate: {
+        process: (
+          input: unknown,
+        ): IValidation<IAutoBeAnalyzeExtractDecisionsApplicationProps> => {
+          if (isRecord(input) && typeof input.request === "string") {
+            input = {
+              ...input,
+              request: tryParseStringAsRecord(input.request),
+            };
+          }
+          return typia.validate<IAutoBeAnalyzeExtractDecisionsApplicationProps>(
+            input,
+          );
+        },
+      },
+    });
+  return {
+    protocol: "class",
+    name: SOURCE,
+    application,
+    execute: {
+      process: (input) => {
+        if (input.request.type === "complete")
+          props.pointer.value = input.request;
+      },
+    } satisfies IAutoBeAnalyzeExtractDecisionsApplication,
+  };
+}
+
+const SOURCE = "analyzeSectionReview" satisfies AutoBeEventSource;

package/src/orchestrate/analyze/orchestrateAnalyzeSectionCrossFileReview.ts

@@ -47,6 +47,7 @@ export const orchestrateAnalyzeSectionCrossFileReview = async (
       status: "approved" | "rewritten" | "new";
     }>;
     mechanicalViolationSummary?: string;
+    fileDecisions?: import("./utils/detectDecisionConflicts").IFileDecisions[];
     progress: AutoBeProgressEventBase;
     promptCacheKey: string;
     retry: number;
@@ -77,6 +78,7 @@ export const orchestrateAnalyzeSectionCrossFileReview = async (
         scenario: props.scenario,
         allFileSummaries: props.allFileSummaries,
         mechanicalViolationSummary: props.mechanicalViolationSummary,
+        fileDecisions: props.fileDecisions,
         preliminary,
       }),
     });

package/src/orchestrate/analyze/structures/IAutoBeAnalyzeExtractDecisionsApplication.ts

@@ -0,0 +1,99 @@
+/**
+ * Application interface for the Key Decision Extractor agent.
+ *
+ * This agent extracts binary/discrete decisions from a single file's section
+ * content as structured data. The extracted decisions are then compared
+ * programmatically across files to detect contradictions.
+ */
+export interface IAutoBeAnalyzeExtractDecisionsApplication {
+  /**
+   * Process decision extraction from a single file's sections.
+   *
+   * Reads the file content and extracts all binary/discrete decisions as
+   * structured data for cross-file contradiction detection.
+   *
+   * @param props Request containing extracted decisions
+   */
+  process(props: IAutoBeAnalyzeExtractDecisionsApplicationProps): void;
+}
+
+export interface IAutoBeAnalyzeExtractDecisionsApplicationProps {
+  /**
+   * Think before you act.
+   *
+   * Before completing extraction, reflect on what decisions this file makes:
+   *
+   * - What binary (yes/no) choices does this file assert?
+   * - What discrete behavioral choices does this file make?
+   * - Are there decisions where another file could reasonably disagree?
+   */
+  thinking?: string | null;
+
+  /** Extraction result. */
+  request: IAutoBeAnalyzeExtractDecisionsApplicationComplete;
+}
+
+/** Request to complete the decision extraction. */
+export interface IAutoBeAnalyzeExtractDecisionsApplicationComplete {
+  /** Type discriminator for the request. */
+  type: "complete";
+
+  /**
+   * All binary/discrete decisions extracted from this file.
+   *
+   * Each decision represents a specific behavioral choice that the file makes.
+   * Use normalized topic names, decision names, and values.
+   *
+   * Return an empty array if the file has no extractable decisions (e.g., table
+   * of contents).
+   */
+  decisions: IAutoBeAnalyzeExtractedDecision[];
+}
+
+/** A single extracted decision from the file's content. */
+export interface IAutoBeAnalyzeExtractedDecision {
+  /**
+   * Normalized topic grouping.
+   *
+   * Use lowercase, underscore-separated names.
+   *
+   * @example
+   *   (password_change, "todo_deletion", "edit_history");
+   */
+  topic: string;
+
+  /**
+   * Specific decision within the topic.
+   *
+   * Use lowercase, underscore-separated, descriptive names.
+   *
+   * @example
+   *   (requires_current_password, "deletion_method", "recorded_values");
+   */
+  decision: string;
+
+  /**
+   * The value of the decision.
+   *
+   * For binary decisions: "yes" or "no". For discrete decisions: short
+   * descriptive string.
+   *
+   * @example
+   *   (yes,
+   *     "no",
+   *     "soft_delete",
+   *     "hard_delete",
+   *     "new_values",
+   *     "previous_values");
+   */
+  value: string;
+
+  /**
+   * Short quote (1-2 sentences) from the source text supporting this decision.
+   *
+   * @example
+   *   "A user may change their password only by providing their
+   *   current password."
+   */
+  evidence: string;
+}

package/src/orchestrate/analyze/structures/IAutoBeAnalyzeScenarioApplication.ts

@@ -129,12 +129,22 @@ export namespace IAutoBeAnalyzeScenarioApplication {
     /**
      * High-level project features that activate conditional modules.
      *
-     * Selected from a FIXED catalog — the LLM must NOT invent features outside
-     * the predefined list. Each feature activates additional modules in the
-     * appropriate SRS files.
+     * WARNING: Wrong activation causes cascading hallucination across ALL SRS
+     * files. Each feature adds 2-3 conditional modules that downstream LLMs
+     * MUST fill with content — if the user never requested the feature, those
+     * modules get filled with hallucinated requirements.
      *
-     * If the project has no special features beyond REST CRUD, return an empty
-     * array.
+     * DEFAULT IS EMPTY ARRAY []. Most projects need no features.
+     *
+     * Activation rule: Include ONLY if the user used exact trigger keywords:
+     *
+     * - "file-storage": user said "file upload", "attachment", "image upload"
+     * - "real-time": user said "real-time", "WebSocket", "live updates", "chat"
+     * - "external-integration": user said "payment", "Stripe", "OAuth", "email
+     *   service"
+     *
+     * Standard CRUD with auth = features: []. Do NOT activate features based on
+     * inference or general context.
      */
     features: FixedAnalyzeTemplateFeature[];
   }

package/src/orchestrate/analyze/utils/buildErrorCodeRegistry.ts

@@ -219,8 +219,6 @@ export const validateErrorCodes = (props: {
   return { canonical, references, undefinedReferences, parseErrors };
 };
 
-// ─── Legacy exports (kept for backward compatibility) ───
-
 /**
  * Detect error code conflicts across files.
  *
@@ -304,21 +302,3 @@ export const buildFileErrorCodeConflictMap = (
 
   return map;
 };
-
-/** @deprecated Bridge block registry removed. Use validateErrorCodes() instead. */
-export const buildErrorCodeRegistry = (props: {
-  files: Array<{
-    file: AutoBeAnalyze.IFileScenario;
-    sectionEvents: AutoBeAnalyzeWriteSectionEvent[][];
-  }>;
-}): IErrorCodeRegistryEntry[] => {
-  const result = validateErrorCodes(props);
-  return result.canonical;
-};
-
-/** @deprecated Bridge block injection removed. */
-export const formatErrorCodeRegistryForPrompt = (
-  _registry: IErrorCodeRegistryEntry[],
-): string => {
-  return "";
-};

package/src/orchestrate/analyze/utils/detectDecisionConflicts.ts

@@ -0,0 +1,172 @@
+// ─── Types ───
+
+/**
+ * A single extracted decision from one file's section content.
+ *
+ * Decisions are binary/discrete choices embedded in prose, e.g.:
+ *
+ * - "password change requires current password" → topic: "password_change",
+ *   decision: "requires_current_password", value: "yes"
+ * - "deleted email can be reused" → topic: "deleted_email", decision:
+ *   "can_be_reused", value: "yes"
+ */
+export interface IExtractedDecision {
+  /** Normalized topic grouping (e.g., "password_change", "email_reuse") */
+  topic: string;
+
+  /** Specific decision within the topic (e.g., "requires_current_password") */
+  decision: string;
+
+  /** The value of the decision (e.g., "yes", "no", "soft_delete", "hard_delete") */
+  value: string;
+
+  /** Evidence quote from the source text */
+  evidence: string;
+}
+
+/** Decisions extracted from a single file, returned by the extraction LLM. */
+export interface IFileDecisions {
+  /** The filename this was extracted from */
+  filename: string;
+
+  /** All decisions extracted from this file */
+  decisions: IExtractedDecision[];
+}
+
+/**
+ * A conflict between two or more files that state different values for the same
+ * topic+decision.
+ */
+export interface IDecisionConflict {
+  /** The topic of the conflict */
+  topic: string;
+
+  /** The specific decision that conflicts */
+  decision: string;
+
+  /** All differing values with their source files and evidence */
+  values: Array<{
+    value: string;
+    files: string[];
+    evidence: string;
+  }>;
+}
+
+// ─── Main Detection ───
+
+/**
+ * Detect decision-level conflicts across all files.
+ *
+ * Groups all extracted decisions by `topic + decision` key, then finds cases
+ * where different files assign different values to the same key.
+ *
+ * This catches prose-level contradictions like:
+ *
+ * - File A: "password change requires current password" (yes)
+ * - File B: "password change does not require current password" (no)
+ */
+export const detectDecisionConflicts = (props: {
+  fileDecisions: IFileDecisions[];
+}): IDecisionConflict[] => {
+  // Group by topic+decision
+  const groups: Map<
+    string,
+    Array<{ value: string; filename: string; evidence: string }>
+  > = new Map();
+
+  for (const { filename, decisions } of props.fileDecisions) {
+    for (const d of decisions) {
+      const key = `${normalizeKey(d.topic)}::${normalizeKey(d.decision)}`;
+      if (!groups.has(key)) groups.set(key, []);
+      groups.get(key)!.push({
+        value: normalizeValue(d.value),
+        filename,
+        evidence: d.evidence,
+      });
+    }
+  }
+
+  // Find conflicts: same key, different values
+  const conflicts: IDecisionConflict[] = [];
+
+  for (const [key, entries] of groups) {
+    // Group entries by value
+    const byValue: Map<
+      string,
+      Array<{ filename: string; evidence: string }>
+    > = new Map();
+    for (const entry of entries) {
+      if (!byValue.has(entry.value)) byValue.set(entry.value, []);
+      byValue.get(entry.value)!.push({
+        filename: entry.filename,
+        evidence: entry.evidence,
+      });
+    }
+
+    // If more than one distinct value exists → conflict
+    if (byValue.size <= 1) continue;
+
+    const [topic, decision] = key.split("::");
+    conflicts.push({
+      topic: topic!,
+      decision: decision!,
+      values: [...byValue.entries()].map(([value, sources]) => ({
+        value,
+        files: sources.map((s) => s.filename),
+        evidence: sources[0]?.evidence ?? "",
+      })),
+    });
+  }
+
+  return conflicts;
+};
+
+/**
+ * Build a map from filename → list of decision conflict feedback strings.
+ *
+ * Each file involved in a conflict gets feedback describing the contradiction.
+ */
+export const buildFileDecisionConflictMap = (
+  conflicts: IDecisionConflict[],
+): Map<string, string[]> => {
+  const map: Map<string, string[]> = new Map();
+
+  for (const conflict of conflicts) {
+    const valueSummary = conflict.values
+      .map((v) => `"${v.value}" in [${v.files.join(", ")}]`)
+      .join(" vs ");
+
+    const feedback =
+      `Decision conflict: ${conflict.topic}.${conflict.decision} — ${valueSummary}. ` +
+      `Files must agree on this decision. Align with the canonical source.`;
+
+    // Add feedback to ALL files involved in this conflict
+    for (const valueGroup of conflict.values) {
+      for (const filename of valueGroup.files) {
+        if (!map.has(filename)) map.set(filename, []);
+        map.get(filename)!.push(feedback);
+      }
+    }
+  }
+
+  return map;
+};
+
+// ─── Helpers ───
+
+/**
+ * Normalize a key string for grouping: lowercase, replace whitespace/special
+ * chars with underscore, trim.
+ */
+function normalizeKey(s: string): string {
+  return s
+    .toLowerCase()
+    .trim()
+    .replace(/[\s\-\.]+/g, "_")
+    .replace(/[^a-z0-9_]/g, "");
+}
+
+/** Normalize a value for comparison: lowercase, trim, collapse whitespace. */
+function normalizeValue(s: string): string {
+  return s.toLowerCase().trim().replace(/\s+/g, " ");
+}

package/src/orchestrate/interface/orchestrateInterfaceSchemaRefine.ts

@@ -36,8 +36,7 @@ export async function orchestrateInterfaceSchemaRefine(
     .filter(
       ([k, v]) =>
         AutoBeJsonSchemaValidator.isPreset(k) === false &&
-        AutoBeOpenApiTypeChecker.isObject(v) &&
-        Object.keys(v.properties).length !== 0,
+        AutoBeOpenApiTypeChecker.isObject(v),
     )
     .map(([k]) => k);
   props.progress.total += typeNames.length;