@autobe/agent 0.9.1 → 0.10.0

package/lib/orchestrate/prisma/orchestratePrismaSchema.js.map

@@ -1 +1 @@
-{"version":3,"file":"orchestratePrismaSchema.js","sourceRoot":"","sources":["../../../src/orchestrate/prisma/orchestratePrismaSchema.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYA,4DA8BC;;;AA1CD,yCAAoE;AAKpE,kDAA0B;AAG1B,uEAAoE;AACpE,iEAA8D;AAC9D,qFAAkF;AAElF,SAAsB,wBAAwB,CAC5C,GAAyB,EACzB,UAAoD;;QAEpD,MAAM,KAAK,GAAS,IAAI,IAAI,EAAE,CAAC;QAC/B,MAAM,YAAY,GAAa,KAAK,CAAC,IAAI,CACvC,IAAI,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAC7C,CAAC;QAEF,MAAM,KAAK,GAAW,UAAU,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;QAC9E,IAAI,CAAC,GAAW,CAAC,CAAC;QAClB,OAAO,MAAM,OAAO,CAAC,GAAG,CACtB,UAAU,CAAC,GAAG,CAAC,CAAO,CAAC,EAAE,EAAE;;YACzB,MAAM,MAAM,GAA+B,MAAM,OAAO,CAAC,GAAG,EAAE;gBAC5D,QAAQ,EAAE,CAAC,CAAC,QAAQ;gBACpB,MAAM,EAAE,CAAC,CAAC,MAAM;gBAChB,YAAY;aACb,CAAC,CAAC;YACH,MAAM,KAAK,GAA6B;gBACtC,IAAI,EAAE,eAAe;gBACrB,UAAU,EAAE,KAAK,CAAC,WAAW,EAAE;gBAC/B,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,SAAS,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC;gBACjC,KAAK;gBACL,IAAI,EAAE,MAAA,MAAA,GAAG,CAAC,KAAK,EAAE,CAAC,OAAO,0CAAE,IAAI,mCAAI,CAAC;aACrC,CAAC;YACF,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;YACpB,OAAO,KAAK,CAAC;QACf,CAAC,CAAA,CAAC,CACH,CAAC;IACJ,CAAC;CAAA;AAED,SAAe,OAAO,CACpB,GAAyB,EACzB,SAIC;;;QAED,MAAM,OAAO,GAAgD;YAC3D,KAAK,EAAE,IAAI;SACZ,CAAC;QACF,MAAM,QAAQ,GAAyB,IAAI,oBAAa,CAAC;YACvD,KAAK,EAAE,GAAG,CAAC,KAAK;YAChB,MAAM,EAAE,GAAG,CAAC,MAAM;YAClB,MAAM,oBACD,CAAC,MAAA,GAAG,CAAC,MAAM,mCAAI,EAAE,CAAC,CACtB;YACD,SAAS,EAAE,IAAA,+DAA8B,EAAC,GAAG,CAAC,KAAK,EAAE,CAAC,OAAQ,EAAE,SAAS,CAAC;YAC1E,UAAU,EAAE,GAAG,CAAC,KAAK,EAAE;YACvB,WAAW,EAAE;gBACX,iBAAiB,CAAC;oBAChB,KAAK,EAAE,GAAG,CAAC,KAAK;oBAChB,KAAK,EAAE,CAAC,IAAI,EAAE,EAAE;;wBACd,MAAA,OAAO,CAAC,KAAK,oCAAb,OAAO,CAAC,KAAK,GAAK;4BAChB,IAAI,EAAE;gCACJ,QAAQ,EAAE,SAAS,CAAC,QAAQ;gCAC5B,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC,SAAS;gCAC9B,MAAM,EAAE,EAAE;6BACX;yBACF,EAAC;wBACF,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;oBACtD,CAAC;iBACF,CAAC;aACH;SACF,CAAC,CAAC;QACH,IAAA,iCAAe,EAAC,QAAQ,CAAC,CAAC;QAC1B,MAAM,QAAQ,CAAC,UAAU,CAAC,gCAAgC,CAAC,CAAC;QAC5D,IAAI,OAAO,CAAC,KAAK,KAAK,IAAI;YACxB,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;QACnE,OAAO,OAAO,CAAC,KAAK,CAAC;IACvB,CAAC;CAAA;AAED,SAAS,iBAAiB,CAAiC,KAG1D;IACC,IAAA,qCAAiB,EAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC/B,MAAM,WAAW,GAA2B,UAAU,CACpD,KAAK,CAAC,KAAK,CACyB,CAAC;IACvC,OAAO;QACL,QAAQ,EAAE,OAAO;QACjB,IAAI,EAAE,kBAAkB;QACxB,WAAW;QACX,OAAO,EAAE;YACP,oBAAoB,EAAE,CAAC,IAAI,EAAE,EAAE;gBAC7B,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YACpB,CAAC;SACqB;KACzB,CAAC;AACJ,CAAC;AAED,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIT,CAAC;AACJ,MAAM,UAAU,GAAG;IACjB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAIJ;IACH,MAAM;IACN,KAAK,EAAE,MAAM;IACb,QAAQ,EAAE,MAAM;IAChB,KAAK,EAAE,MAAM;IACb,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA8C;CACpD,CAAC"}
+{"version":3,"file":"orchestratePrismaSchema.js","sourceRoot":"","sources":["../../../src/orchestrate/prisma/orchestratePrismaSchema.ts"],"names":[],"mappings":"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"}

package/lib/orchestrate/prisma/transformPrismaComponentsHistories.js

@@ -61,6 +61,15 @@ const transformPrismaComponentsHistories = (state, prefix = null) => {
                 "For example:",
                 "",
                 "* `mv_shopping_daily_stats`",
+                "",
+                "## User Role Handling",
+                "",
+                "If the Requirement Analysis Report contains User Role information, **do not normalize** user roles into a single table.",
+                "Instead, create separate tables for each distinct role mentioned in the requirements.",
+                "",
+                "For example, if the requirements mention User, Admin, and Moderator roles:",
+                "",
+                "* Create separate tables: `User`, `Admin`, `Moderator` (or with prefix: `shopping_user`, `shopping_admin`, `shopping_moderator`)",
             ].join("\n"),
         },
     ];

package/lib/orchestrate/prisma/transformPrismaComponentsHistories.js.map

@@ -1 +1 @@
-{"version":3,"file":"transformPrismaComponentsHistories.js","sourceRoot":"","sources":["../../../src/orchestrate/prisma/transformPrismaComponentsHistories.ts"],"names":[],"mappings":";;;AACA,+BAA0B;AAKnB,MAAM,kCAAkC,GAAG,CAChD,KAAkB,EAClB,SAAwB,IAAI,EAG5B,EAAE;IACF,IAAI,KAAK,CAAC,OAAO,KAAK,IAAI;QACxB,OAAO;YACL;gBACE,EAAE,EAAE,IAAA,SAAE,GAAE;gBACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;gBACpC,IAAI,EAAE,eAAe;gBACrB,IAAI,EAAE;oBACJ,4CAA4C;oBAC5C,+BAA+B;oBAC/B,8CAA8C;iBAC/C,CAAC,IAAI,CAAC,GAAG,CAAC;aACZ;SACF,CAAC;IACJ,OAAO;QACL;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,eAAe;YACrB,IAAI,iiGAA6C;SAClD;QACD;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,kBAAkB;YACxB,IAAI,EAAE;gBACJ,0CAA0C;gBAC1C,EAAE;gBACF,8DAA8D;gBAC9D,gDAAgD;gBAChD,EAAE;gBACF,iBAAiB;gBACjB,KAAK,CAAC,OAAO,CAAC,MAAM;gBACpB,EAAE;gBACF,gCAAgC;gBAChC,EAAE;gBACF,SAAS;gBACT,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;gBACnC,KAAK;gBACL,WAAW;gBACX,EAAE;gBACF,kCAAkC,MAAM,EAAE;gBAC1C,EAAE;gBACF,2FAA2F;gBAC3F,gDAAgD;gBAChD,kEAAkE;gBAClE,yHAAyH;gBACzH,EAAE;gBACF,mBAAmB;gBACnB,EAAE;gBACF,+DAA+D;gBAC/D,EAAE;gBACF,oBAAoB;gBACpB,2BAA2B;gBAC3B,EAAE;gBACF,uIAAuI;gBACvI,cAAc;gBACd,EAAE;gBACF,6BAA6B;aAC9B,CAAC,IAAI,CAAC,IAAI,CAAC;SACb;KACF,CAAC;AACJ,CAAC,CAAC;AAnEW,QAAA,kCAAkC,sCAmE7C"}
+{"version":3,"file":"transformPrismaComponentsHistories.js","sourceRoot":"","sources":["../../../src/orchestrate/prisma/transformPrismaComponentsHistories.ts"],"names":[],"mappings":";;;AACA,+BAA0B;AAKnB,MAAM,kCAAkC,GAAG,CAChD,KAAkB,EAClB,SAAwB,IAAI,EAG5B,EAAE;IACF,IAAI,KAAK,CAAC,OAAO,KAAK,IAAI;QACxB,OAAO;YACL;gBACE,EAAE,EAAE,IAAA,SAAE,GAAE;gBACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;gBACpC,IAAI,EAAE,eAAe;gBACrB,IAAI,EAAE;oBACJ,4CAA4C;oBAC5C,+BAA+B;oBAC/B,8CAA8C;iBAC/C,CAAC,IAAI,CAAC,GAAG,CAAC;aACZ;SACF,CAAC;IACJ,OAAO;QACL;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,eAAe;YACrB,IAAI,iiGAA6C;SAClD;QACD;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,kBAAkB;YACxB,IAAI,EAAE;gBACJ,0CAA0C;gBAC1C,EAAE;gBACF,8DAA8D;gBAC9D,gDAAgD;gBAChD,EAAE;gBACF,iBAAiB;gBACjB,KAAK,CAAC,OAAO,CAAC,MAAM;gBACpB,EAAE;gBACF,gCAAgC;gBAChC,EAAE;gBACF,SAAS;gBACT,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;gBACnC,KAAK;gBACL,WAAW;gBACX,EAAE;gBACF,kCAAkC,MAAM,EAAE;gBAC1C,EAAE;gBACF,2FAA2F;gBAC3F,gDAAgD;gBAChD,kEAAkE;gBAClE,yHAAyH;gBACzH,EAAE;gBACF,mBAAmB;gBACnB,EAAE;gBACF,+DAA+D;gBAC/D,EAAE;gBACF,oBAAoB;gBACpB,2BAA2B;gBAC3B,EAAE;gBACF,uIAAuI;gBACvI,cAAc;gBACd,EAAE;gBACF,6BAA6B;gBAC7B,EAAE;gBACF,uBAAuB;gBACvB,EAAE;gBACF,yHAAyH;gBACzH,uFAAuF;gBACvF,EAAE;gBACF,4EAA4E;gBAC5E,EAAE;gBACF,kIAAkI;aACnI,CAAC,IAAI,CAAC,IAAI,CAAC;SACb;KACF,CAAC;AACJ,CAAC,CAAC;AA5EW,QAAA,kCAAkC,sCA4E7C"}

package/lib/orchestrate/prisma/transformPrismaSchemaHistories.js

@@ -48,6 +48,14 @@ const transformPrismaSchemaHistories = (analyze, component) => {
                 ...component.tables.map((table) => `    - ${table}`),
                 `  - Entire tables you can reference:`,
                 ...component.entireTables.map((table) => `    - ${table}`),
+                "",
+                "## User Role Rules",
+                "",
+                "**CRITICAL**: For User Role tables (User, Admin, Moderator, etc.):",
+                "1. **Separate tables** - Each role = independent table (User, Admin, Moderator tables)",
+                "2. **No `role` field** - Never include role enum fields in any table",
+                "",
+                "You can use TPT (Table Per Type) pattern with FK relationships if needed, or completely separate tables.",
             ].join("\n"),
         },
     ];

package/lib/orchestrate/prisma/transformPrismaSchemaHistories.js.map

@@ -1 +1 @@
-{"version":3,"file":"transformPrismaSchemaHistories.js","sourceRoot":"","sources":["../../../src/orchestrate/prisma/transformPrismaSchemaHistories.ts"],"names":[],"mappings":";;;AAEA,+BAA0B;AAInB,MAAM,8BAA8B,GAAG,CAC5C,OAA6B,EAC7B,SAIC,EAGD,EAAE;IACF,OAAO;QACL;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,eAAe;YACrB,IAAI,8oWAA0C;SAC/C;QACD;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,eAAe;YACrB,IAAI,EAAE;gBACJ,oCAAoC;gBACpC,wCAAwC;gBACxC,sCAAsC;gBACtC,EAAE;;aAEH,CAAC,IAAI,CAAC,IAAI,CAAC;SACb;QACD;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,kBAAkB;YACxB,IAAI,EAAE;gBACJ,0CAA0C;gBAC1C,EAAE;gBACF,8DAA8D;gBAC9D,gDAAgD;gBAChD,EAAE;gBACF,iBAAiB;gBACjB,OAAO,CAAC,MAAM;gBACd,EAAE;gBACF,gCAAgC;gBAChC,EAAE;gBACF,SAAS;gBACT,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC;gBAC7B,KAAK;gBACL,EAAE;gBACF,YAAY;gBACZ,EAAE;gBACF,wBAAwB,SAAS,CAAC,QAAQ,EAAE;gBAC5C,mCAAmC;gBACnC,GAAG,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,SAAS,KAAK,EAAE,CAAC;gBACpD,sCAAsC;gBACtC,GAAG,SAAS,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,SAAS,KAAK,EAAE,CAAC;aAC3D,CAAC,IAAI,CAAC,IAAI,CAAC;SACb;KACF,CAAC;AACJ,CAAC,CAAC;AA1DW,QAAA,8BAA8B,kCA0DzC"}
+{"version":3,"file":"transformPrismaSchemaHistories.js","sourceRoot":"","sources":["../../../src/orchestrate/prisma/transformPrismaSchemaHistories.ts"],"names":[],"mappings":";;;AAEA,+BAA0B;AAInB,MAAM,8BAA8B,GAAG,CAC5C,OAA6B,EAC7B,SAIC,EAGD,EAAE;IACF,OAAO;QACL;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,eAAe;YACrB,IAAI,8oWAA0C;SAC/C;QACD;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,eAAe;YACrB,IAAI,EAAE;gBACJ,oCAAoC;gBACpC,wCAAwC;gBACxC,sCAAsC;gBACtC,EAAE;;aAEH,CAAC,IAAI,CAAC,IAAI,CAAC;SACb;QACD;YACE,EAAE,EAAE,IAAA,SAAE,GAAE;YACR,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,IAAI,EAAE,kBAAkB;YACxB,IAAI,EAAE;gBACJ,0CAA0C;gBAC1C,EAAE;gBACF,8DAA8D;gBAC9D,gDAAgD;gBAChD,EAAE;gBACF,iBAAiB;gBACjB,OAAO,CAAC,MAAM;gBACd,EAAE;gBACF,gCAAgC;gBAChC,EAAE;gBACF,SAAS;gBACT,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC;gBAC7B,KAAK;gBACL,EAAE;gBACF,YAAY;gBACZ,EAAE;gBACF,wBAAwB,SAAS,CAAC,QAAQ,EAAE;gBAC5C,mCAAmC;gBACnC,GAAG,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,SAAS,KAAK,EAAE,CAAC;gBACpD,sCAAsC;gBACtC,GAAG,SAAS,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,SAAS,KAAK,EAAE,CAAC;gBAC1D,EAAE;gBACF,oBAAoB;gBACpB,EAAE;gBACF,oEAAoE;gBACpE,wFAAwF;gBACxF,sEAAsE;gBACtE,EAAE;gBACF,0GAA0G;aAC3G,CAAC,IAAI,CAAC,IAAI,CAAC;SACb;KACF,CAAC;AACJ,CAAC,CAAC;AAlEW,QAAA,8BAA8B,kCAkEzC"}

package/lib/orchestrate/realize/orchestrateRealize.d.ts

@@ -0,0 +1,11 @@
+import { AutoBeAssistantMessageHistory, AutoBeRealizeHistory } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { IAutoBeApplicationProps } from "../../context/IAutoBeApplicationProps";
+export declare const orchestrateRealize: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>) => (props: IAutoBeApplicationProps) => Promise<AutoBeAssistantMessageHistory | AutoBeRealizeHistory>;
+export declare const FAILED: unique symbol;
+export type FAILED = typeof FAILED;
+export declare function pipe<A, B>(a: A, ab: (a: A) => Promise<B | FAILED>): Promise<B | FAILED>;
+export declare function pipe<A, B, C>(a: A, ab: (a: A) => Promise<B | FAILED>, bc: (b: B) => Promise<C | FAILED>): Promise<C | FAILED>;
+export declare 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 declare 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>;

package/lib/orchestrate/realize/orchestrateRealize.js

@@ -0,0 +1,109 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAILED = exports.orchestrateRealize = void 0;
+exports.pipe = pipe;
+const uuid_1 = require("uuid");
+const orchestrateRealizeCoder_1 = require("./orchestrateRealizeCoder");
+const orchestrateRealizeIntegrator_1 = require("./orchestrateRealizeIntegrator");
+const orchestrateRealizePlanner_1 = require("./orchestrateRealizePlanner");
+const orchestrateRealizeValidator_1 = require("./orchestrateRealizeValidator");
+const orchestrateRealize = (ctx) => (props) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c, _d, _e, _f;
+    props;
+    const ops = (_a = ctx.state().interface) === null || _a === void 0 ? void 0 : _a.document.operations;
+    if (!ops) {
+        throw new Error();
+    }
+    const codes = yield Promise.all(ops.map((op) => __awaiter(void 0, void 0, void 0, function* () {
+        return pipe(op, (op) => (0, orchestrateRealizePlanner_1.orchestrateRealizePlanner)(ctx, op), (p) => (0, orchestrateRealizeCoder_1.orchestrateRealizeCoder)(ctx, op, p));
+    })));
+    const vaildates = yield Promise.all(codes
+        .filter((el) => el !== exports.FAILED)
+        .map((c) => __awaiter(void 0, void 0, void 0, function* () {
+        return pipe(c, (c) => (0, orchestrateRealizeIntegrator_1.orchestrateRealizeIntegrator)(ctx, c), (i) => (0, orchestrateRealizeValidator_1.orchestrateRealizeValidator)(ctx, i));
+    })));
+    if (vaildates.length) {
+        if (vaildates.every((v) => v !== exports.FAILED)) {
+            const files = Object.assign(Object.assign({}, (_b = ctx.state().interface) === null || _b === void 0 ? void 0 : _b.files), vaildates
+                .map((v) => ({ [v.location]: v.content }))
+                .reduce((acc, cur) => Object.assign(acc, cur), {}));
+            const compiled = yield ctx.compiler.typescript.compile({ files });
+            const now = new Date().toISOString();
+            ctx.dispatch({
+                type: "realizeComplete",
+                compiled: compiled,
+                created_at: now,
+                files: files,
+                step: (_d = (_c = ctx.state().analyze) === null || _c === void 0 ? void 0 : _c.step) !== null && _d !== void 0 ? _d : 0,
+            });
+            return {
+                id: (0, uuid_1.v4)(),
+                type: "realize",
+                completed_at: now,
+                created_at: now,
+                compiled,
+                files,
+                reason: props.reason,
+                step: (_f = (_e = ctx.state().analyze) === null || _e === void 0 ? void 0 : _e.step) !== null && _f !== void 0 ? _f : 0,
+            };
+        }
+        else {
+            const total = codes.length;
+            const failedCount = codes.filter((code) => code === exports.FAILED).length;
+            const successCount = total - failedCount;
+            const now = new Date().toISOString();
+            ctx.dispatch({
+                type: "assistantMessage",
+                text: [
+                    `Out of ${total} code blocks, ${successCount} succeeded, but ${failedCount} failed.`,
+                    `The process has been stopped due to the failure. Please review the failed steps and try again.`,
+                ].join("\n"),
+                created_at: now,
+            });
+            return {
+                id: (0, uuid_1.v4)(),
+                type: "assistantMessage",
+                completed_at: now,
+                created_at: now,
+                text: [
+                    `Out of ${total} code blocks, ${successCount} succeeded, but ${failedCount} failed.`,
+                    `The process has been stopped due to the failure. Please review the failed steps and try again.`,
+                ].join("\n"),
+            };
+        }
+    }
+    const now = new Date().toISOString();
+    ctx.dispatch({
+        type: "assistantMessage",
+        text: "Any codes can not be generated.",
+        created_at: now,
+    });
+    return {
+        id: (0, uuid_1.v4)(),
+        type: "assistantMessage",
+        completed_at: now,
+        created_at: now,
+        text: "Any codes can not be generated.",
+    };
+});
+exports.orchestrateRealize = orchestrateRealize;
+exports.FAILED = Symbol("FAILED");
+function pipe(a, ...fns) {
+    return fns.reduce((prev, fn) => {
+        return prev.then((result) => {
+            if (result === exports.FAILED)
+                return exports.FAILED;
+            return fn(result);
+        });
+    }, Promise.resolve(a));
+}
+//# sourceMappingURL=orchestrateRealize.js.map

package/lib/orchestrate/realize/orchestrateRealize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrateRealize.js","sourceRoot":"","sources":["../../../src/orchestrate/realize/orchestrateRealize.ts"],"names":[],"mappings":"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"}

package/lib/orchestrate/realize/orchestrateRealizeCoder.d.ts

@@ -0,0 +1,25 @@
+import { AutoBeOpenApi } from "@autobe/interface";
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { FAILED } from "./orchestrateRealize";
+import { RealizePlannerOutput } from "./orchestrateRealizePlanner";
+import { IAutoBeRealizeCoderApplication } from "./structures/IAutoBeRealizeCoderApplication";
+/**
+ * Generates a TypeScript function implementation based on the given plan.
+ *
+ * This function transforms the plan (function name, input/output schema,
+ * constraints, and scenarios) into a complete TypeScript function as a string.
+ * It is responsible only for producing the code logic, and does not handle
+ * imports, exports, or formatting.
+ *
+ * Import statements are handled separately and will be injected automatically.
+ * Any unused imports will be removed by tooling (e.g. eslint).
+ *
+ * Type annotations should be omitted whenever possible to favor TypeScript's
+ * type inference, unless explicit types are critical to correctness.
+ *
+ * @param ctx - AutoBE execution context
+ * @param props - Planning result describing what function to generate
+ * @returns The generated function name and TypeScript code
+ */
+export declare const orchestrateRealizeCoder: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, operation: AutoBeOpenApi.IOperation, props: RealizePlannerOutput) => Promise<IAutoBeRealizeCoderApplication.RealizeCoderOutput | FAILED>;

package/lib/orchestrate/realize/orchestrateRealizeCoder.js

@@ -0,0 +1,337 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.orchestrateRealizeCoder = void 0;
+const __typia_transform__validateReport = __importStar(require("typia/lib/internal/_validateReport.js"));
+const core_1 = require("@agentica/core");
+const prettier_plugin_sort_imports_1 = __importDefault(require("@trivago/prettier-plugin-sort-imports"));
+const prettier_1 = require("prettier");
+const typia_1 = __importDefault(require("typia"));
+const assertSchemaModel_1 = require("../../context/assertSchemaModel");
+const enforceToolCall_1 = require("../../utils/enforceToolCall");
+const getTestScenarioArtifacts_1 = require("../test/compile/getTestScenarioArtifacts");
+const orchestrateRealize_1 = require("./orchestrateRealize");
+const transformRealizeCoderHistories_1 = require("./transformRealizeCoderHistories");
+/**
+ * Generates a TypeScript function implementation based on the given plan.
+ *
+ * This function transforms the plan (function name, input/output schema,
+ * constraints, and scenarios) into a complete TypeScript function as a string.
+ * It is responsible only for producing the code logic, and does not handle
+ * imports, exports, or formatting.
+ *
+ * Import statements are handled separately and will be injected automatically.
+ * Any unused imports will be removed by tooling (e.g. eslint).
+ *
+ * Type annotations should be omitted whenever possible to favor TypeScript's
+ * type inference, unless explicit types are critical to correctness.
+ *
+ * @param ctx - AutoBE execution context
+ * @param props - Planning result describing what function to generate
+ * @returns The generated function name and TypeScript code
+ */
+const orchestrateRealizeCoder = (ctx, operation, props) => __awaiter(void 0, void 0, void 0, function* () {
+    const artifacts = yield (0, getTestScenarioArtifacts_1.getTestScenarioArtifacts)(ctx, {
+        endpoint: {
+            method: operation.method,
+            path: operation.path,
+        },
+        dependencies: [],
+    });
+    const pointer = {
+        value: null,
+    };
+    const controller = createApplication({
+        model: ctx.model,
+        build: (props) => {
+            pointer.value = props.result;
+        },
+    });
+    const agent = new core_1.MicroAgentica({
+        controllers: [controller],
+        model: ctx.model,
+        vendor: ctx.vendor,
+        config: Object.assign(Object.assign({}, ctx.config), { executor: {
+                describe: null,
+            } }),
+        histories: (0, transformRealizeCoderHistories_1.transformRealizeCoderHistories)(ctx.state(), props, artifacts),
+    });
+    (0, enforceToolCall_1.enforceToolCall)(agent);
+    yield agent.conversate("Write code.");
+    const tokenUsage = agent.getTokenUsage();
+    ctx.usage().record(tokenUsage, ["realize"]);
+    if (pointer.value === null) {
+        return orchestrateRealize_1.FAILED;
+    }
+    pointer.value.implementationCode = yield (0, prettier_1.format)(pointer.value.implementationCode, {
+        parser: "typescript",
+        plugins: [prettier_plugin_sort_imports_1.default, yield Promise.resolve().then(() => __importStar(require("prettier-plugin-jsdoc")))],
+        importOrder: ["<THIRD_PARTY_MODULES>", "^[./]"],
+        importOrderSeparation: true,
+        importOrderSortSpecifiers: true,
+        importOrderParserPlugins: ["decorators-legacy", "typescript", "jsx"],
+    });
+    pointer.value.implementationCode = pointer.value.implementationCode
+        .replaceAll('import { MyGlobal } from "../MyGlobal";', "")
+        .replaceAll('import typia, { tags } from "typia";', "")
+        .replaceAll('import { Prisma } from "@prisma/client";', "")
+        .replaceAll('import { jwtDecode } from "./jwtDecode"', "");
+    pointer.value.implementationCode = [
+        'import { MyGlobal } from "../MyGlobal";',
+        'import typia, { tags } from "typia";',
+        'import { Prisma } from "@prisma/client";',
+        'import { jwtDecode } from "./jwtDecode"',
+        "",
+        pointer.value.implementationCode,
+    ].join("\n");
+    return Object.assign(Object.assign({}, pointer.value), { functionName: props.functionName });
+});
+exports.orchestrateRealizeCoder = orchestrateRealizeCoder;
+function createApplication(props) {
+    (0, assertSchemaModel_1.assertSchemaModel)(props.model);
+    const application = collection[props.model];
+    return {
+        protocol: "class",
+        name: "Write code",
+        application,
+        execute: {
+            programing: (next) => {
+                props.build(next);
+            },
+        },
+    };
+}
+const claude = {
+    model: "claude",
+    options: {
+        reference: true,
+        separate: null
+    },
+    functions: [
+        {
+            name: "programing",
+            parameters: {
+                description: "Current Type: {@link IAutoBeRealizeCoderApplication.IProps}",
+                type: "object",
+                properties: {
+                    result: {
+                        $ref: "#/$defs/IAutoBeRealizeCoderApplication.RealizeCoderOutput"
+                    }
+                },
+                required: [
+                    "result"
+                ],
+                additionalProperties: false,
+                $defs: {
+                    "IAutoBeRealizeCoderApplication.RealizeCoderOutput": {
+                        description: "The result of the code generation step, representing a fully generated\nTypeScript function.",
+                        type: "object",
+                        properties: {
+                            functionName: {
+                                title: "The name of the function to be generated",
+                                description: "The name of the function to be generated.\n\nThis name will be used as the function's identifier and as the export\nname in the provider file.",
+                                type: "string"
+                            },
+                            implementationCode: {
+                                title: "The raw TypeScript code string implementing the function",
+                                description: "The raw TypeScript code string implementing the function.\n\n- The implementation must be valid TypeScript code.\n- It should focus solely on the logic of the function.\n- Import statements do **not** need to be included. They will be\n  automatically inserted by the system.\n- Any unused imports will be automatically removed by eslint.\n- Type annotations (e.g. for parameters and return types) should be omitted\n  if they can be inferred.",
+                                type: "string"
+                            }
+                        },
+                        required: [
+                            "functionName",
+                            "implementationCode"
+                        ]
+                    }
+                }
+            },
+            validate: (() => { const _io0 = input => "object" === typeof input.result && null !== input.result && _io1(input.result); const _io1 = input => "string" === typeof input.functionName && "string" === typeof input.implementationCode; const _vo0 = (input, _path, _exceptionable = true) => [("object" === typeof input.result && null !== input.result || _report(_exceptionable, {
+                    path: _path + ".result",
+                    expected: "IAutoBeRealizeCoderApplication.RealizeCoderOutput",
+                    value: input.result
+                })) && _vo1(input.result, _path + ".result", true && _exceptionable) || _report(_exceptionable, {
+                    path: _path + ".result",
+                    expected: "IAutoBeRealizeCoderApplication.RealizeCoderOutput",
+                    value: input.result
+                })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.functionName || _report(_exceptionable, {
+                    path: _path + ".functionName",
+                    expected: "string",
+                    value: input.functionName
+                }), "string" === typeof input.implementationCode || _report(_exceptionable, {
+                    path: _path + ".implementationCode",
+                    expected: "string",
+                    value: input.implementationCode
+                })].every(flag => flag); const __is = input => "object" === typeof input && null !== input && _io0(input); let errors; let _report; return input => {
+                if (false === __is(input)) {
+                    errors = [];
+                    _report = __typia_transform__validateReport._validateReport(errors);
+                    ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                        path: _path + "",
+                        expected: "IAutoBeRealizeCoderApplication.IProps",
+                        value: input
+                    })) && _vo0(input, _path + "", true) || _report(true, {
+                        path: _path + "",
+                        expected: "IAutoBeRealizeCoderApplication.IProps",
+                        value: input
+                    }))(input, "$input", true);
+                    const success = 0 === errors.length;
+                    return success ? {
+                        success,
+                        data: input
+                    } : {
+                        success,
+                        errors,
+                        data: input
+                    };
+                }
+                return {
+                    success: true,
+                    data: input
+                };
+            }; })()
+        }
+    ]
+};
+const collection = {
+    chatgpt: {
+        model: "chatgpt",
+        options: {
+            reference: true,
+            strict: false,
+            separate: null
+        },
+        functions: [
+            {
+                name: "programing",
+                parameters: {
+                    description: "Current Type: {@link IAutoBeRealizeCoderApplication.IProps}",
+                    type: "object",
+                    properties: {
+                        result: {
+                            $ref: "#/$defs/IAutoBeRealizeCoderApplication.RealizeCoderOutput"
+                        }
+                    },
+                    required: [
+                        "result"
+                    ],
+                    additionalProperties: false,
+                    $defs: {
+                        "IAutoBeRealizeCoderApplication.RealizeCoderOutput": {
+                            description: "The result of the code generation step, representing a fully generated\nTypeScript function.",
+                            type: "object",
+                            properties: {
+                                functionName: {
+                                    title: "The name of the function to be generated",
+                                    description: "The name of the function to be generated.\n\nThis name will be used as the function's identifier and as the export\nname in the provider file.",
+                                    type: "string"
+                                },
+                                implementationCode: {
+                                    title: "The raw TypeScript code string implementing the function",
+                                    description: "The raw TypeScript code string implementing the function.\n\n- The implementation must be valid TypeScript code.\n- It should focus solely on the logic of the function.\n- Import statements do **not** need to be included. They will be\n  automatically inserted by the system.\n- Any unused imports will be automatically removed by eslint.\n- Type annotations (e.g. for parameters and return types) should be omitted\n  if they can be inferred.",
+                                    type: "string"
+                                }
+                            },
+                            required: [
+                                "functionName",
+                                "implementationCode"
+                            ]
+                        }
+                    }
+                },
+                validate: (() => { const _io0 = input => "object" === typeof input.result && null !== input.result && _io1(input.result); const _io1 = input => "string" === typeof input.functionName && "string" === typeof input.implementationCode; const _vo0 = (input, _path, _exceptionable = true) => [("object" === typeof input.result && null !== input.result || _report(_exceptionable, {
+                        path: _path + ".result",
+                        expected: "IAutoBeRealizeCoderApplication.RealizeCoderOutput",
+                        value: input.result
+                    })) && _vo1(input.result, _path + ".result", true && _exceptionable) || _report(_exceptionable, {
+                        path: _path + ".result",
+                        expected: "IAutoBeRealizeCoderApplication.RealizeCoderOutput",
+                        value: input.result
+                    })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.functionName || _report(_exceptionable, {
+                        path: _path + ".functionName",
+                        expected: "string",
+                        value: input.functionName
+                    }), "string" === typeof input.implementationCode || _report(_exceptionable, {
+                        path: _path + ".implementationCode",
+                        expected: "string",
+                        value: input.implementationCode
+                    })].every(flag => flag); const __is = input => "object" === typeof input && null !== input && _io0(input); let errors; let _report; return input => {
+                    if (false === __is(input)) {
+                        errors = [];
+                        _report = __typia_transform__validateReport._validateReport(errors);
+                        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                            path: _path + "",
+                            expected: "IAutoBeRealizeCoderApplication.IProps",
+                            value: input
+                        })) && _vo0(input, _path + "", true) || _report(true, {
+                            path: _path + "",
+                            expected: "IAutoBeRealizeCoderApplication.IProps",
+                            value: input
+                        }))(input, "$input", true);
+                        const success = 0 === errors.length;
+                        return success ? {
+                            success,
+                            data: input
+                        } : {
+                            success,
+                            errors,
+                            data: input
+                        };
+                    }
+                    return {
+                        success: true,
+                        data: input
+                    };
+                }; })()
+            }
+        ]
+    },
+    claude,
+    llama: claude,
+    deepseek: claude,
+    "3.1": claude,
+};
+//# sourceMappingURL=orchestrateRealizeCoder.js.map

package/lib/orchestrate/realize/orchestrateRealizeCoder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrateRealizeCoder.js","sourceRoot":"","sources":["../../../src/orchestrate/realize/orchestrateRealizeCoder.ts"],"names":[],"mappings":"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"}

package/lib/orchestrate/realize/orchestrateRealizeIntegrator.d.ts

@@ -0,0 +1,52 @@
+import { ILlmSchema } from "@samchon/openapi";
+import { AutoBeContext } from "../../context/AutoBeContext";
+import { IAutoBeRealizeCoderApplication } from "./structures/IAutoBeRealizeCoderApplication";
+/**
+ * The result of integrating the generated code into the actual application
+ * files (e.g., controller).
+ */
+export interface RealizeIntegratorOutput {
+    /**
+     * Indicates the result of the integration process.
+     *
+     * - "success": The function was correctly inserted, imported, and passed
+     *   compilation.
+     * - "fail": The integration did not complete (e.g., target controller not
+     *   found, syntax error).
+     * - "exception": An unexpected error occurred (e.g., I/O failure, invalid
+     *   context state).
+     */
+    result: "success" | "fail" | "exception";
+}
+/**
+ * Integrates the generated function into an appropriate controller file,
+ * handling insertion, import, and static validation.
+ *
+ * This function performs the following steps:
+ *
+ * 1. **Locate appropriate controller file**
+ *
+ *    - Usually matches `*.controller.ts`
+ *    - May be based on inferred target (e.g., from functionName or folder structure)
+ * 2. **Insert the generated function into the file content**
+ *
+ *    - Ensures proper placement, such as inside a class or export block
+ *    - May replace or append to existing function stubs
+ * 3. **Inject required imports automatically**
+ *
+ *    - Identifies any missing imports (e.g., DTOs, utility functions)
+ *    - Ensures imports are added without duplication
+ * 4. **Check for compile-time safety**
+ *
+ *    - Ensures TypeScript type-checking passes
+ *    - Verifies that Nestia-generated routers still function without error
+ *    - If compilation fails or static types are invalid, marks result as `"fail"`
+ *
+ * ⚠️ Note: This step **must not rely on runtime execution**. It only guarantees
+ * static, structural validity (i.e., valid TypeScript).
+ *
+ * @param ctx - AutoBE context including current source files and settings
+ * @param props - Output from the code generation step to be integrated
+ * @returns Integration status, indicating success or failure of insertion
+ */
+export declare const orchestrateRealizeIntegrator: <Model extends ILlmSchema.Model>(ctx: AutoBeContext<Model>, props: IAutoBeRealizeCoderApplication.RealizeCoderOutput) => Promise<RealizeIntegratorOutput>;