@autobe/agent 0.29.1 → 0.29.2

package/lib/index.mjs

@@ -30,55 +30,6 @@ import * as __typia_transform__isUniqueItems from "typia/lib/internal/_isUniqueI
 
 import * as __typia_transform__createStandardSchema from "typia/lib/internal/_createStandardSchema.js";
 
-const getAutoBeRealizeGenerated = async props => ({
-    ...Object.fromEntries(props.functions.map(f => [ f.location, f.content ])),
-    ...Object.fromEntries(props.authorizations.map(auth => [ [ auth.decorator.location, auth.decorator.content ], [ auth.provider.location, auth.provider.content ], [ auth.payload.location, auth.payload.content ] ]).flat()),
-    ...await props.compiler.realize.getTemplate(props.options),
-    ...await props.compiler.realize.controller({
-        document: props.document,
-        functions: props.functions,
-        authorizations: props.authorizations
-    })
-});
-
-async function getAutoBeGenerated(compiler, state, histories, tokenUsage, options) {
-    const ret = {};
-    if (state.analyze === null) return {};
-    Object.assign(ret, Object.fromEntries(state.analyze.files.map(file => [ `docs/analysis/${file.filename.split("/").at(-1)}`, file.content ])));
-    if (options?.stage === "analyze") return ret;
-    if (state.prisma?.step === state.analyze.step) {
-        const schemaFiles = (options?.dbms ?? "postgres") === "postgres" ? state.prisma.schemas : await compiler.prisma.write(state.prisma.result.data, options.dbms);
-        Object.assign(ret, Object.fromEntries(Object.entries(schemaFiles).map(([key, value]) => [ `prisma/schema/${key.split("/").at(-1)}`, value ])), {
-            "autobe/prisma.json": JSON.stringify(state.prisma.result.data)
-        });
-        if (state.prisma.compiled.type === "success") ret["docs/ERD.md"] = state.prisma.compiled.document; else if (state.prisma.compiled.type === "failure") ret["prisma/compile-error-reason.log"] = state.prisma.compiled.reason;
-    }
-    if (options?.stage === "prisma") return ret;
-    if (state.interface?.step === state.analyze.step) {
-        const files = await compiler.interface.write(state.interface.document);
-        Object.assign(ret, state.test?.step === state.interface.step ? Object.fromEntries(Object.entries(files).filter(([key]) => key.startsWith("test/features/") === false)) : files, {
-            "autobe/document.json": JSON.stringify(state.interface.document)
-        });
-    }
-    if (options?.stage === "interface") return ret;
-    if (state.test?.step === state.analyze.step) Object.assign(ret, Object.fromEntries(state.test.files.map(f => [ f.location, f.content ])), await compiler.test.getTemplate());
-    if (state.realize?.step === state.analyze.step) Object.assign(ret, await getAutoBeRealizeGenerated({
-        compiler,
-        document: state.interface.document,
-        authorizations: state.realize.authorizations,
-        functions: state.realize.functions,
-        options: {
-            dbms: options?.dbms ?? "postgres"
-        }
-    }));
-    if (options?.stage === "test") return ret;
-    Object.assign(ret, {
-        "autobe/histories.json": JSON.stringify(histories),
-        "autobe/tokenUsage.json": JSON.stringify(tokenUsage)
-    });
-    return ret;
-}
-
 function emplaceMap(dict, key, generator) {
     const oldbie = dict.get(key);
     if (oldbie !== undefined) {
@@ -90,13 +41,9 @@ function emplaceMap(dict, key, generator) {
 }
 
 class AutoBeAgentBase {
-    constructor(asset) {
-        this.asset = asset;
+    constructor() {
         this.listeners_ = new Map;
     }
-    async getFiles(options) {
-        return getAutoBeGenerated(await this.asset.compiler(), this.asset.state(), this.getHistories(), this.getTokenUsage(), options);
-    }
     on(type, listener) {
         emplaceMap(this.listeners_, type, () => new Set).add(listener);
         return this;
@@ -605,10 +552,9 @@ const getCriticalCompiler = (critical, compiler) => {
             write: (app, dmbs) => lock(() => compiler.prisma.write(app, dmbs))
         },
         interface: {
-            write: doc => lock(() => compiler.interface.write(doc)),
+            write: (doc, exclude) => lock(() => compiler.interface.write(doc, exclude)),
             transform: doc => lock(() => compiler.interface.transform(doc)),
-            invert: doc => lock(() => compiler.interface.invert(doc)),
-            getTemplate: () => lock(() => compiler.interface.getTemplate())
+            invert: doc => lock(() => compiler.interface.invert(doc))
         },
         typescript: {
             compile: props => lock(() => compiler.typescript.compile(props)),
@@ -619,14 +565,13 @@ const getCriticalCompiler = (critical, compiler) => {
             compile: props => lock(() => compiler.test.compile(props)),
             validate: props => lock(() => compiler.test.validate(props)),
             write: props => lock(() => compiler.test.write(props)),
-            getExternal: () => lock(() => compiler.test.getExternal()),
-            getTemplate: () => lock(() => compiler.test.getTemplate())
+            getExternal: () => lock(() => compiler.test.getExternal())
         },
         realize: {
             controller: props => lock(() => compiler.realize.controller(props)),
-            test: props => lock(() => compiler.realize.test(props)),
-            getTemplate: options => lock(() => compiler.realize.getTemplate(options))
-        }
+            test: props => lock(() => compiler.realize.test(props))
+        },
+        getTemplate: options => lock(() => compiler.getTemplate(options))
     };
 };
 
@@ -963,6 +908,108 @@ const createAutoBeState = histories => {
     };
 };
 
+const getAutoBeRealizeGenerated = async props => ({
+    ...Object.fromEntries(props.functions.map(f => [ f.location, f.content ])),
+    ...Object.fromEntries(props.authorizations.map(auth => [ [ auth.decorator.location, auth.decorator.content ], [ auth.provider.location, auth.provider.content ], [ auth.payload.location, auth.payload.content ] ]).flat()),
+    ...await props.compiler.realize.controller({
+        document: props.document,
+        functions: props.functions,
+        authorizations: props.authorizations
+    })
+});
+
+async function getAutoBeGenerated(props) {
+    const options = {
+        phase: props.options?.phase ?? props.state.realize ? "realize" : props.state.test ? "test" : props.state.interface ? "interface" : "analyze",
+        dbms: props.options?.dbms ?? "postgres"
+    };
+    const ret = await props.compiler.getTemplate(options);
+    ret["README.md"] = writeReadMe(props.state, ret["README.md"]);
+    if (props.state.analyze === null) return ret;
+    Object.assign(ret, Object.fromEntries(props.state.analyze.files.map(file => [ `docs/analysis/${file.filename.split("/").at(-1)}`, file.content ])));
+    if (props.options?.phase === "analyze") return ret;
+    if (props.state.prisma?.step === props.state.analyze.step) {
+        const schemaFiles = (options?.dbms ?? "postgres") === "postgres" ? props.state.prisma.schemas : await props.compiler.prisma.write(props.state.prisma.result.data, options.dbms);
+        Object.assign(ret, Object.fromEntries(Object.entries(schemaFiles).map(([key, value]) => [ `prisma/schema/${key.split("/").at(-1)}`, value ])), {
+            "autobe/prisma.json": JSON.stringify(props.state.prisma.result.data)
+        });
+        if (props.state.prisma.compiled.type === "success") ret["docs/ERD.md"] = props.state.prisma.compiled.document; else if (props.state.prisma.compiled.type === "failure") ret["prisma/compile-error-reason.log"] = props.state.prisma.compiled.reason;
+    }
+    if (props.options?.phase === "prisma") return ret;
+    if (props.state.interface?.step === props.state.analyze.step) {
+        const files = await props.compiler.interface.write(props.state.interface.document, Object.keys(ret));
+        Object.assign(ret, props.state.test?.step === props.state.interface.step ? Object.fromEntries(Object.entries(files).filter(([key]) => key.startsWith("test/features/") === false)) : files, {
+            "autobe/document.json": JSON.stringify(props.state.interface.document)
+        });
+    }
+    if (props.options?.phase === "interface") return ret;
+    if (props.state.test?.step === props.state.analyze.step) Object.assign(ret, Object.fromEntries(props.state.test.files.map(f => [ f.location, f.content ])));
+    if (props.state.realize?.step === props.state.analyze.step) Object.assign(ret, await getAutoBeRealizeGenerated({
+        compiler: props.compiler,
+        document: props.state.interface.document,
+        authorizations: props.state.realize.authorizations,
+        functions: props.state.realize.functions,
+        options: {
+            dbms: options?.dbms ?? "postgres"
+        }
+    }));
+    if (props.options?.phase === "test") return ret;
+    Object.assign(ret, {
+        "autobe/histories.json": JSON.stringify(props.histories),
+        "autobe/tokenUsage.json": JSON.stringify(props.tokenUsage)
+    });
+    return ret;
+}
+
+function writeReadMe(state, readme) {
+    const emoji = history => history ? success(history) ? "✅" : "❌" : "⬜";
+    return readme.replaceAll("{{ANALYSIS_EMOJI}}", emoji(state.analyze)).replaceAll("{{PRISMA_EMOJI}}", emoji(state.prisma)).replaceAll("{{INTERFACE_EMOJI}}", emoji(state.interface)).replaceAll("{{TEST_EMOJI}}", emoji(state.test)).replaceAll("{{REALIZE_EMOJI}}", emoji(state.realize)).replaceAll("{{BENCHMARK_AGGREGATE}}", writeBenchmarkAggregate(state)).replaceAll("{{BENCHMARK_FUNCTION_CALLING}}", writeBenchmarkFunctionCalling(state));
+}
+
+function writeBenchmarkAggregate(state) {
+    return [ "analyze", "prisma", "interface", "test", "realize" ].map(key => {
+        const h = state[key];
+        if (h === null) return `⬜ ${key} | | | | `;
+        return [ `${success(h) ? "✅" : "❌"} ${h.type}`, Object.entries(label(h)).map(([k, v]) => `${k}: ${v.toLocaleString()}`).join(", "), (h.aggregates.total.metric.success / h.aggregates.total.metric.attempt * 100).toFixed(2) + " %", h.aggregates.total.tokenUsage.total.toLocaleString(), Math.round((new Date(h.completed_at).getTime() - new Date(h.created_at).getTime()) / 1e3) + " sec" ].join(" | ");
+    }).join("\n");
+}
+
+function writeBenchmarkFunctionCalling(state) {
+    const aggregates = AutoBeProcessAggregateFactory.reduce([ state.analyze, state.prisma, state.interface, state.test, state.realize ].filter(h => h !== null).map(h => h.aggregates));
+    return Object.entries(aggregates).map(([key, value]) => [ key, value.metric.attempt.toLocaleString(), value.metric.validationFailure.toLocaleString(), value.metric.invalidJson.toLocaleString(), value.metric.success.toLocaleString(), (value.metric.success / value.metric.attempt * 100).toFixed(2) + " %" ].join(" | ")).join("\n");
+}
+
+function success(history) {
+    if (history.type === "analyze") return true; else if (history.type === "interface") return history.missed.length === 0; else if (history.type === "prisma" || history.type === "test" || history.type === "realize") return history.compiled.type === "success";
+    throw new Error("Unknown history type encountered.");
+}
+
+function label(history) {
+    if (history.type === "analyze") return {
+        actors: history.actors.length,
+        documents: history.files.length
+    }; else if (history.type === "prisma") return {
+        namespaces: history.result.data.files.length,
+        models: history.result.data.files.map(f => f.models).flat().length
+    }; else if (history.type === "interface") return {
+        operations: history.document.operations.length,
+        schemas: Object.keys(history.document.components.schemas).length
+    }; else if (history.type === "test") {
+        return {
+            functions: history.files.length,
+            ...history.compiled.type === "failure" ? {
+                errors: new Set(history.compiled.diagnostics.map(d => d.file ?? "")).size
+            } : {}
+        };
+    } else if (history.type === "realize") return {
+        functions: history.functions.length,
+        ...history.compiled.type === "failure" ? {
+            errors: new Set(history.compiled.diagnostics.map(d => d.file ?? "")).size
+        } : {}
+    };
+    throw new Error("Unknown history type encountered.");
+}
+
 function assertSchemaModel(model) {
     if (model === "3.0") throw new Error([ "Error on AutoBeAgent.constructor(): schema version 3.0 is not supported", "due to limitations in the JSON schema specification for function calling.", "Please use a different model that supports modern JSON schema features." ].join(" "));
 }
@@ -51692,7 +51739,8 @@ async function compileRealizeFiles(ctx, props) {
     const prisma = ctx.state().prisma?.compiled;
     const payloads = Object.fromEntries(props.authorizations.map(el => [ el.payload.location, el.payload.content ]));
     const compiler = await ctx.compiler();
-    const templateFiles = await compiler.realize.getTemplate({
+    const templateFiles = await compiler.getTemplate({
+        phase: "realize",
         dbms: "sqlite"
     });
     const nodeModules = prisma?.type === "success" ? prisma.nodeModules : {};
@@ -53202,7 +53250,8 @@ async function orchestrateRealizeAuthorizationWrite(ctx) {
         total: actors.length,
         completed: 0
     };
-    const templates = await (await ctx.compiler()).realize.getTemplate({
+    const templates = await (await ctx.compiler()).getTemplate({
+        phase: "realize",
         dbms: "sqlite"
     });
     const authorizations = await executeCachedBatch(ctx, actors.map(a => promptCacheKey => process$4(ctx, {
@@ -54859,7 +54908,7 @@ function filterDiagnostics(failures, locations) {
 async function getRealizeWriteDto(ctx, operation) {
     const document = filterDocument$1(operation, ctx.state().interface.document);
     const compiler = await ctx.compiler();
-    const entries = Object.entries(await compiler.interface.write(document));
+    const entries = Object.entries(await compiler.interface.write(document, []));
     const filter = (prefix, exclude) => {
         const result = entries.filter(([key]) => key.startsWith(prefix) === true);
         return Object.fromEntries(result);
@@ -59411,7 +59460,7 @@ const correct = async (ctx, props, life) => {
     pointer.value.draft = await completeTestCode(ctx, props.function.artifacts, pointer.value.draft);
     ctx.dispatch({
         type: "testCorrect",
-        kind: "casting",
+        kind: "overall",
         id: v7(),
         created_at: (new Date).toISOString(),
         file: props.validate.file,
@@ -63865,7 +63914,7 @@ const getTestTemplateCode = (scenario, document) => StringUtil.trim`
 async function getTestScenarioArtifacts(ctx, scenario) {
     const compiler = await ctx.compiler();
     const document = filterDocument(scenario, ctx.state().interface.document);
-    const entries = Object.entries(await compiler.interface.write(document));
+    const entries = Object.entries(await compiler.interface.write(document, []));
     const filter = (prefix, exclude) => {
         const result = entries.filter(([key]) => key.startsWith(prefix) === true);
         return Object.fromEntries(exclude ? result.filter(([key]) => key.startsWith(exclude) === false) : result);
@@ -65700,10 +65749,7 @@ function isRetryError(error) {
 
 class AutoBeAgent extends AutoBeAgentBase {
     constructor(props) {
-        super({
-            compiler: () => this.context_.compiler(),
-            state: () => this.state_
-        });
+        super();
         this.props_ = props;
         this.histories_ = props.histories?.slice() ?? [];
         this.state_ = createAutoBeState(this.histories_);
@@ -65857,6 +65903,15 @@ class AutoBeAgent extends AutoBeAgentBase {
     getTokenUsage() {
         return this.usage_;
     }
+    async getFiles(options) {
+        return await getAutoBeGenerated({
+            compiler: await this.context_.compiler(),
+            state: this.state_,
+            histories: this.getHistories(),
+            tokenUsage: this.getTokenUsage(),
+            options
+        });
+    }
     getAggregates(latest = false) {
         if (latest === false) return this.aggregates_;
         const state = this.context_.state();
@@ -65887,10 +65942,7 @@ var index = Object.freeze({
 
 class AutoBeMockAgent extends AutoBeAgentBase {
     constructor(props) {
-        super({
-            compiler: () => this.compiler_.get(),
-            state: () => createAutoBeState(this.histories_)
-        });
+        super();
         this.props_ = props;
         this.histories_ = [];
         this.compiler_ = new Singleton(async () => props.compiler({
@@ -65959,6 +66011,15 @@ class AutoBeMockAgent extends AutoBeAgentBase {
     getTokenUsage() {
         return this.token_usage_;
     }
+    async getFiles(options) {
+        return await getAutoBeGenerated({
+            compiler: await this.compiler_.get(),
+            state: createAutoBeState(this.histories_),
+            histories: this.getHistories(),
+            tokenUsage: this.getTokenUsage(),
+            options
+        });
+    }
     getPhase() {
         const state = createAutoBeState(this.histories_);
         if (state.analyze === null) return null; else if (state.realize?.step === state.analyze.step) return "realize"; else if (state.test?.step === state.analyze.step) return "test"; else if (state.interface?.step === state.analyze.step) return "interface"; else if (state.prisma?.step === state.analyze.step) return "prisma";