@voltro/cli 0.33.0 → 0.35.0

package/dist/frameworkTableAssembly-oMPBKqlE.js

@@ -0,0 +1,511 @@
+import { n as e } from "./appModuleLoader-C9r9mxZt.js";
+import { D as t, a as n, j as r, k as i, x as a } from "./fileConventions-Cof68_BL.js";
+import { basename as o, join as s } from "node:path";
+import { existsSync as c, promises as l } from "node:fs";
+import { pathToFileURL as u } from "node:url";
+import { defineAction as d, defineMutation as f, defineQuery as ee } from "@voltro/protocol";
+import { Effect as p } from "effect";
+import { SqlClient as m } from "@effect/sql";
+import { _voltroBudgetHoldsTable as te, _voltroWorkflowAdmissionsTable as ne, _voltroWorkflowPausesTable as re, _voltroWorkflowPendingTable as ie, _voltroWorkflowRunEventsTable as ae, _voltroWorkflowRunStepsTable as oe, _voltroWorkflowRunsTable as se, _voltroWorkflowStartContextsTable as ce, _voltroWorkflowWatermarksTable as le } from "@voltro/workflow";
+import { agentMessagesTable as ue, agentThreadsTable as de, aiBudgetTable as fe, aiInferencesTable as pe, aiUsageTable as me, isAgentDescriptor as he, isAgentExecutor as ge, promptsTable as h, resolveToolModuleHandlers as g } from "@voltro/ai";
+import { _voltroApiKeysTable as _, _voltroCdcOffsetsTable as v, _voltroIdempotencyTable as y, _voltroKvTable as b, _voltroMigrationPlansTable as x, _voltroMigrationsTable as S, _voltroMssqlCdcOffsetsTable as C, _voltroSeedsTable as w } from "@voltro/database";
+import { _voltroApprovalsTable as T, _voltroConnectionGrantsTable as E, _voltroConnectionsTable as D, _voltroScheduleClaimsTable as O, _voltroScheduleRunsTable as k, _voltroTracesTable as A, _voltroUndoLogTable as j, _voltroWakeupsTable as M, _voltroWorkflowEventDeliveriesTable as N, _voltroWorkflowEventsTable as P, outboxAttemptsTable as F, outboxTable as I } from "@voltro/runtime";
+import { _voltroWebhookDeliveriesTable as L, _voltroWebhookTargetsTable as _e } from "@voltro/plugin-webhooks/mixin";
+import { _voltroStorageBlobsTable as ve, _voltroStorageGrantsTable as ye, _voltroStorageRefsTable as be, _voltroStorageUsageTable as xe } from "@voltro/plugin-storage";
+//#region src/frameworkTables.ts
+var Se = [
+	{
+		table: S,
+		when: "always"
+	},
+	{
+		table: w,
+		when: "always"
+	},
+	{
+		table: x,
+		when: "always"
+	},
+	{
+		table: se,
+		when: "workflows"
+	},
+	{
+		table: oe,
+		when: "workflows"
+	},
+	{
+		table: ae,
+		when: "workflows"
+	},
+	{
+		table: ce,
+		when: "workflows"
+	},
+	{
+		table: ie,
+		when: "workflows"
+	},
+	{
+		table: ne,
+		when: "workflows"
+	},
+	{
+		table: re,
+		when: "workflows"
+	},
+	{
+		table: le,
+		when: "workflows"
+	},
+	{
+		table: P,
+		when: "workflows"
+	},
+	{
+		table: N,
+		when: "workflows"
+	},
+	{
+		table: k,
+		when: "schedules"
+	},
+	{
+		table: O,
+		when: "schedules"
+	},
+	{
+		table: _e,
+		when: "webhooks"
+	},
+	{
+		table: L,
+		when: "webhooks"
+	},
+	{
+		table: A,
+		when: "traces"
+	},
+	{
+		table: j,
+		when: "undo"
+	},
+	{
+		table: T,
+		when: "always"
+	},
+	{
+		table: te,
+		when: "workflows"
+	},
+	{
+		table: I,
+		when: "always"
+	},
+	{
+		table: F,
+		when: "always"
+	},
+	{
+		table: D,
+		when: "connections"
+	},
+	{
+		table: E,
+		when: "connections"
+	},
+	{
+		table: M,
+		when: "always"
+	},
+	{
+		table: be,
+		when: "always"
+	},
+	{
+		table: ye,
+		when: "always"
+	},
+	{
+		table: ve,
+		when: "always"
+	},
+	{
+		table: xe,
+		when: "always"
+	},
+	{
+		table: y,
+		when: "always"
+	},
+	{
+		table: _,
+		when: "always"
+	},
+	{
+		table: b,
+		when: "always"
+	}
+], Ce = (e) => {
+	let t = Se.filter((t) => t.when === "always" || t.when === "workflows" && e.workflows || t.when === "schedules" && e.schedules || t.when === "webhooks" && e.webhooks || t.when === "traces" && e.traces || t.when === "undo" && e.undo === !0 || t.when === "connections" && e.connections === !0).map((e) => e.table);
+	return e.cdc === !0 && t.push(e.cdcDialect === "mssql" ? C : v), t;
+}, R = (e) => {
+	let t = e.startsWith("@") ? e.replace(/^@[^/]+\//, "") : e;
+	return (t.startsWith("plugin-") ? t.slice(7) : t).replace(/-([a-zA-Z0-9])/g, (e, t) => t.toUpperCase());
+}, we = (e) => {
+	let t = e.startsWith("@") ? e.replace(/^@[^/]+\//, "") : e;
+	return (t.startsWith("plugin-") ? t.slice(7) : t).replace(/#/g, "--").replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+}, Te = (e, t) => z(e, t.name), z = (e, t) => {
+	let n = R(e.name);
+	if (!t.includes(".")) return `${n}.${t}`;
+	if (e.baseName === void 0) return t;
+	let r = `${R(e.baseName)}.`;
+	return t.startsWith(r) ? `${n}.${t.slice(r.length)}` : t;
+}, B = (e) => e.openAccess === void 0 ? e.guards !== void 0 && e.guards.length > 0 ? { guards: e.guards } : {} : { openAccess: e.openAccess }, Ee = (e, t, n) => {
+	switch (e) {
+		case "query": return ee({
+			name: t,
+			input: n.input,
+			output: n.output,
+			...n.error === void 0 ? {} : { error: n.error },
+			...B(n),
+			...n.source === void 0 ? {} : { source: n.source }
+		});
+		case "mutation": return f({
+			name: t,
+			input: n.input,
+			output: n.output,
+			...n.error === void 0 ? {} : { error: n.error },
+			...B(n)
+		});
+		case "action": return d({
+			name: t,
+			input: n.input,
+			output: n.output,
+			...n.error === void 0 ? {} : { error: n.error },
+			...B(n)
+		});
+	}
+}, De = (e) => (t, n) => p.suspend(() => {
+	let r = { request: {
+		subject: n.request.subject,
+		traceId: n.request.traceId
+	} };
+	return e.execute(t, r);
+}), Oe = (e) => {
+	let t = [];
+	for (let n of e) {
+		let e = n.routes ?? [];
+		for (let r of e) {
+			let e = Te(n, r), i = Ee(r.kind, e, r);
+			t.push({
+				kind: r.kind,
+				file: `plugin:${n.name}`,
+				descriptor: i,
+				executor: De(r),
+				plugin: {
+					name: n.name,
+					version: n.version
+				}
+			});
+		}
+	}
+	return t;
+}, ke = (e, t, n = /* @__PURE__ */ new Set()) => {
+	let r = /* @__PURE__ */ new Map();
+	for (let e of t) r.set(e, "user-route");
+	let i = [];
+	for (let t of e) {
+		let e = t.descriptor.name, a = r.get(e);
+		if (!(a === "user-route" && n.has(e))) {
+			if (a !== void 0) throw Error(`plugin route tag collision: "${e}" declared by plugin "${t.plugin.name}" but already claimed by ${a === "user-route" ? "a user-authored route" : `plugin "${a}"`}` + (a === "user-route" ? `.\nIf replacing it is intentional, declare \`overridesPlugin: true\` on your "${e}" — renaming yours or aliasing the plugin both split the namespace by who built it.` : ""));
+			r.set(e, t.plugin.name), i.push(t);
+		}
+	}
+	return i;
+}, V = "_voltro_plugin_migrations", Ae = () => p.gen(function* () {
+	yield* (yield* m.SqlClient).unsafe(`
+      CREATE TABLE IF NOT EXISTS ${V} (
+        id          TEXT PRIMARY KEY,
+        plugin_name TEXT NOT NULL,
+        migration_id TEXT NOT NULL,
+        description TEXT,
+        applied_at  TEXT NOT NULL
+      );
+    `).pipe(p.orDie);
+}), je = (e, t) => `${R(e)}__${t}`, Me = () => p.gen(function* () {
+	let e = yield* m.SqlClient, t = yield* e`SELECT id FROM ${e(V)}`.pipe(p.orDie);
+	return new Set(t.map((e) => e.id));
+}), Ne = (e) => p.gen(function* () {
+	let t = yield* m.SqlClient, n = (/* @__PURE__ */ new Date()).toISOString();
+	yield* t`
+        INSERT INTO ${t(V)} (id, plugin_name, migration_id, description, applied_at)
+        VALUES (${e.key}, ${e.pluginName}, ${e.migration.id}, ${e.migration.description ?? null}, ${n})
+      `.pipe(p.orDie);
+}), H = (e) => p.gen(function* () {
+	let t = e.flatMap((e) => (e.extendSchema?.migrations ?? []).map((t) => ({
+		plugin: e,
+		migration: t
+	})));
+	if (t.length === 0) return [];
+	yield* Ae();
+	let n = yield* Me(), r = [];
+	for (let { plugin: e, migration: i } of t) {
+		let t = je(e.name, i.id), a = Date.now();
+		if (n.has(t)) {
+			r.push({
+				pluginName: e.name,
+				migrationId: i.id,
+				status: "skipped",
+				durationMs: 0
+			});
+			continue;
+		}
+		let o = yield* m.SqlClient;
+		try {
+			yield* i.up(o).pipe(p.mapError((e) => e)), yield* Ne({
+				key: t,
+				pluginName: e.name,
+				migration: i
+			}), r.push({
+				pluginName: e.name,
+				migrationId: i.id,
+				status: "applied",
+				durationMs: Date.now() - a
+			});
+		} catch (t) {
+			return r.push({
+				pluginName: e.name,
+				migrationId: i.id,
+				status: "failed",
+				durationMs: Date.now() - a,
+				error: t
+			}), yield* p.fail(/* @__PURE__ */ Error(`Plugin migration failed: ${e.name} ${i.id} — ${t instanceof Error ? t.message : String(t)}`));
+		}
+	}
+	return r;
+}), Pe = (e, t) => p.gen(function* () {
+	let n = yield* H(e);
+	if (n.length === 0) return n;
+	let r = n.filter((e) => e.status === "applied"), i = n.filter((e) => e.status === "skipped");
+	return t(`plugin migrations: ${r.length} applied, ${i.length} already applied`, { applied: r.map((e) => `${e.pluginName}:${e.migrationId}`) }), n;
+}), Fe = (e) => e.filter((e) => e.extendSchema && (e.extendSchema.tables?.length ?? 0) + (e.extendSchema.migrations?.length ?? 0) > 0).map((e) => ({
+	pluginName: e.name,
+	pluginAlias: R(e.name),
+	tables: e.extendSchema.tables?.length ?? 0,
+	migrations: e.extendSchema.migrations?.length ?? 0
+})), Ie = (e) => e.flatMap((e) => e.extendSchema?.tables ?? []), U = /(?<!\.server)\.agent\.tsx?$/, Le = /\.agent\.server\.tsx?$/, W = /\.tool\.tsx?$/, Re = async (t, n) => {
+	let r = 0;
+	for (let i of t) if (W.test(i)) try {
+		let t = await e(i);
+		r += g(t);
+	} catch (e) {
+		n.warn("tool: failed to import — handler not wired", { file: i }, e);
+	}
+	return r;
+}, ze = (e) => e.replace(/\.agent\.(tsx?)$/, ".agent.server.$1"), Be = async (t, n) => {
+	let r = [], i = /* @__PURE__ */ new Set();
+	for (let a of t) {
+		if (!U.test(a)) continue;
+		let t;
+		try {
+			t = await e(a);
+		} catch (e) {
+			n.warn("agent: failed to import descriptor", { file: a }, e);
+			continue;
+		}
+		let o = Object.values(t).find(he);
+		if (o === void 0) {
+			n.warn("agent: no defineAgent() descriptor export found", { file: a });
+			continue;
+		}
+		if (i.has(o.name)) {
+			n.warn("agent: duplicate name — skipping", {
+				file: a,
+				name: o.name
+			});
+			continue;
+		}
+		let s = ze(a), c;
+		try {
+			c = await e(s);
+		} catch (e) {
+			n.warn("agent: no executor — expected a `*.agent.server.tsx` default-exporting defineAgentExecutor()", {
+				descriptor: a,
+				expected: s,
+				name: o.name
+			}, e);
+			continue;
+		}
+		let l = c.default;
+		if (!ge(l)) {
+			n.warn("agent: executor file must default-export defineAgentExecutor(descriptor, {...})", {
+				file: s,
+				name: o.name
+			});
+			continue;
+		}
+		i.add(o.name), r.push({
+			file: a,
+			serverFile: s,
+			descriptor: o,
+			executor: l
+		});
+	}
+	return { agents: r };
+}, G = /\.connection\.tsx?$/, Ve = (e) => e.replace(G, ""), K = async (t, n) => {
+	let r = [], i = /* @__PURE__ */ new Map();
+	for (let a of t) {
+		let t;
+		try {
+			t = await e(a);
+		} catch (e) {
+			n.warn("connections: failed to import", { file: a }, e);
+			continue;
+		}
+		let o = t.default;
+		if (o === void 0 || typeof o != "object" || !o) {
+			n.warn("connections: missing or non-object default export — expected `defineConnection({...})`", { file: a });
+			continue;
+		}
+		let s = o;
+		if (typeof s.id != "string" || s.id.length === 0) {
+			n.warn("connections: invalid `id` field", { file: a });
+			continue;
+		}
+		if (s.kind !== "oauth2" && s.kind !== "pat") {
+			n.warn("connections: `kind` must be \"oauth2\" or \"pat\"", {
+				file: a,
+				kind: String(s.kind)
+			});
+			continue;
+		}
+		let c = i.get(s.id);
+		if (c !== void 0) {
+			n.error("connections: DUPLICATE id — only the first is registered", {
+				id: s.id,
+				registered: c,
+				ignored: a
+			});
+			continue;
+		}
+		i.set(s.id, a), r.push({
+			file: a,
+			definition: s
+		});
+	}
+	return r.length > 0 && n.info("discovered connections", {
+		connections: r.map((e) => `${e.definition.id} (${e.definition.kind})`),
+		files: r.map((e) => Ve(o(e.file)))
+	}), r;
+}, q = (e) => {
+	let t = e.nodeEnv !== "production";
+	return {
+		traces: e.declared?.traces ?? t,
+		undo: e.declared?.undo ?? t,
+		cdc: e.cdcDialect !== void 0
+	};
+}, He = (e) => {
+	let t = e.nodeEnv ?? "<unset>", n = (n) => e.declared?.[n] === void 0 ? `the default for NODE_ENV=${t}` : `app.config.ts \`schema: { ${n}: ${String(e.declared[n])} }\``, r = (e, t, n) => `  ${e ? "+" : "-"} ${t.padEnd(22)} ${n}`;
+	return `The three tables whose presence is DECIDED rather than implied by your source tree —
+compare these against the other process's environment before anything else:
+
+${r(e.gates.traces, "_voltro_traces", n("traces"))}\n${r(e.gates.undo, "_voltro_undo_log", n("undo"))}\n${r(e.gates.cdc, "_voltro_cdc_offsets", `DB_DIALECT=${e.cdcDialect ?? "<no out-of-band CDC>"}`)}\n\nNone of them reads a runtime flag any more. If you are upgrading FROM a version where\nthey did, a migrate job without \`CDC\` / \`VOLTRO_UNDO\` / \`VOLTRO_TRACING_PERSIST\` recorded\na different set than your pods computed — re-run \`voltro db apply\` once on this version.`;
+}, Ue = (e) => {
+	let t = [{
+		key: "traces",
+		table: "_voltro_traces",
+		envVar: "VOLTRO_TRACING_PERSIST"
+	}, {
+		key: "undo",
+		table: "_voltro_undo_log",
+		envVar: "VOLTRO_UNDO"
+	}].filter((t) => e.runtime[t.key] && !e.gates[t.key]);
+	if (t.length !== 0) return `refusing to boot — a runtime flag asks for a table the deployment does not declare:\n\n${t.map(({ key: e, table: t, envVar: n }) => `  \`${n}\` turns ${e} capture ON, but \`${t}\` is not in this app's declared schema.\n  Declare it: \`schema: { ${e}: true }\` in app.config.ts.`).join("\n\n")}\n\nThe declaration has to live in app.config.ts rather than in the environment because the\npre-deploy migrate job runs with its OWN env block. A flag set on the pods and not on the\njob produces a green apply and a schema fingerprint no container can reproduce.`;
+}, J = (e) => n.test(e) || a.test(e), Y = async (e) => {
+	let n = !1, a = !1, o = !1, c = !1, u = !1, d = async (e) => {
+		let f = await l.readdir(e, { withFileTypes: !0 }).catch(() => []);
+		for (let l of f) if (l.isDirectory()) {
+			if (l.name === "node_modules" || l.name === "dist" || l.name === ".framework" || l.name.startsWith(".")) continue;
+			await d(s(e, l.name));
+		} else {
+			let e = l.name;
+			(r.test(e) || t.test(e)) && (n = !0), J(e) && (a = !0), i.test(e) && (o = !0), U.test(e) && (c = !0), G.test(e) && (u = !0);
+		}
+	};
+	return await d(e), {
+		workflows: n,
+		schedules: a,
+		webhooks: o,
+		agents: c,
+		connections: u
+	};
+}, We = async (e) => {
+	let t = s(e, "app.config.ts");
+	if (!c(t)) return { plugins: [] };
+	try {
+		let e = await import(u(t).href);
+		return {
+			plugins: e.default?.plugins ?? [],
+			...e.default?.schema ? { schema: e.default.schema } : {}
+		};
+	} catch (e) {
+		return {
+			plugins: [],
+			error: e
+		};
+	}
+}, Ge = async (e) => (await X(e)).plugins, X = async (e) => {
+	let { plugins: t, schema: n, error: r } = await We(e);
+	if (r !== void 0) throw new Z(e, r);
+	return {
+		plugins: t,
+		...n ? { schema: n } : {}
+	};
+}, Z = class extends Error {
+	root;
+	cause;
+	constructor(e, t) {
+		super(`app.config.ts could not be imported, so this app's plugin list is EMPTY and every plugin table is missing from the schema.
+
+This is refused rather than continued: a plan computed without them does not merely omit them, it proposes DROPPING them, and the failure surfaces later as a pluginRef error naming an unrelated plugin.
+
+The import ran at config-evaluation time — anything your config imports, directly or transitively, that does work when the module is first evaluated will reach here.
+
+Cause: ${t instanceof Error ? t.message : String(t)}`), this.root = e, this.cause = t, this.name = "AppConfigLoadError";
+	}
+}, Q = (e) => {
+	let t = /* @__PURE__ */ new Map(), n = (e) => {
+		e?.tableName && !t.has(e.tableName) && t.set(e.tableName, e);
+	};
+	for (let t of Ce({
+		workflows: e.mix.workflows,
+		schedules: e.mix.schedules,
+		webhooks: e.mix.webhooks,
+		traces: e.gates.traces,
+		cdc: e.gates.cdc,
+		...e.cdcDialect ? { cdcDialect: e.cdcDialect } : {},
+		undo: e.gates.undo,
+		connections: e.mix.connections
+	})) n(t);
+	e.mix.agents && (n(de), n(ue), n(me), n(fe)), e.mix.workflows && n(pe), (e.mix.workflows || e.mix.agents) && n(h);
+	for (let t of Ie(e.plugins)) n(t);
+	return [...t.values()];
+}, Ke = async (e) => {
+	let t = await Y(e.root), { plugins: n, schema: r } = await X(e.root);
+	return Q({
+		mix: t,
+		plugins: n,
+		gates: q({
+			nodeEnv: process.env.NODE_ENV,
+			cdcDialect: $(),
+			declared: r
+		}),
+		...$() ? { cdcDialect: $() } : {}
+	});
+}, $ = (e = process.env) => {
+	let t = (e.DB_DIALECT ?? "postgres").toLowerCase();
+	return t === "mariadb" ? "mariadb" : t === "mssql" ? "mssql" : void 0;
+};
+//#endregion
+export { Oe as C, we as E, ke as S, R as T, Be as _, Y as a, H as b, X as c, Ue as d, G as f, W as g, Le as h, $ as i, He as l, U as m, Ke as n, J as o, K as p, Q as r, Ge as s, Z as t, q as u, Re as v, z as w, Fe as x, Pe as y };

package/dist/generateCommand-DbgcUpGw.js

@@ -0,0 +1,147 @@
+import { r as e } from "./appGraph-KGDPTuTy.js";
+import { dirname as t, join as n } from "node:path";
+import { promises as r } from "node:fs";
+import { createLogger as i } from "@voltro/logger";
+import { Effect as a, Schema as o } from "effect";
+import { generateObject as s } from "@voltro/ai";
+//#region src/appBuilder.ts
+var c = 3, l = 50, u = 256 * 1024, d = (e) => e.reduce((e, t) => e + Buffer.byteLength(t.content, "utf8"), 0), f = async (t, n) => {
+	let r = Math.max(1, n.maxAttempts ?? c), i = n.maxArtifacts ?? l, a = n.maxTotalBytes ?? u, o = [];
+	for (let s = 1; s <= r; s++) {
+		let r = await n.generate({
+			prompt: t,
+			attempt: s,
+			priorDiagnostics: o
+		});
+		if (r.artifacts.length === 0) return {
+			status: "rejected",
+			reason: "empty",
+			attempts: s,
+			diagnostics: []
+		};
+		if (r.artifacts.length > i || d(r.artifacts) > a) return {
+			status: "rejected",
+			reason: "too-large",
+			attempts: s,
+			diagnostics: []
+		};
+		let c = e(r.graph);
+		if (c.ok) return {
+			status: "accepted",
+			proposal: r,
+			attempts: s,
+			diagnostics: c.diagnostics
+		};
+		o = c.diagnostics;
+	}
+	return {
+		status: "rejected",
+		reason: "check-failed",
+		attempts: r,
+		diagnostics: o
+	};
+}, p = o.Struct({
+	tag: o.String,
+	kind: o.String,
+	file: o.optional(o.String),
+	source: o.optional(o.Union(o.String, o.Array(o.String))),
+	targets: o.optional(o.Array(o.Struct({
+		table: o.String,
+		op: o.String
+	}))),
+	binds: o.optional(o.Array(o.String)),
+	requiresScopes: o.optional(o.Array(o.String))
+}), m = o.Struct({
+	tables: o.Array(o.String),
+	procedures: o.Array(p),
+	scopes: o.optional(o.Array(o.String)),
+	routes: o.optional(o.Array(o.Struct({
+		pattern: o.String,
+		binds: o.Array(o.String),
+		file: o.optional(o.String)
+	})))
+}), h = o.Struct({
+	graph: m,
+	artifacts: o.Array(o.Struct({
+		path: o.String,
+		content: o.String
+	}))
+}), g = (e, t) => {
+	let n = [
+		"You are a Voltro app builder. Emit a structured proposal: the app GRAPH",
+		"(tables + procedures + routes) AND the FILES (artifacts) that realise it.",
+		"",
+		"You may ONLY use these framework primitives / conventions:",
+		...e.length > 0 ? e.map((e) => `- ${e}`) : ["- (no capability manifest provided)"],
+		"",
+		"Rules:",
+		"- Every procedure `tag` is `<domain>.<action>` (camelCase segments).",
+		"- A query declares `source` (the table(s) it reads); a mutation declares",
+		"  `targets` ([{ table, op }]); a route `binds` rpc tags that MUST exist.",
+		"- `requiresScopes` lists the RBAC scopes a handler needs (must be in `scopes`).",
+		"- Emit one artifact per file with its full `content`. Keep it minimal + valid."
+	];
+	return t.length > 0 && n.push("", "Your PREVIOUS attempt FAILED these checks — FIX each before re-emitting:", ...t.map((e) => `- [${e.rule}]${e.node ? ` ${e.node}` : ""}: ${e.breaks}${e.fix ? ` → ${e.fix}` : ""}`)), n.join("\n");
+}, _ = (e) => async ({ prompt: t, priorDiagnostics: n }) => await a.runPromise(s({
+	schema: h,
+	prompt: t,
+	system: g(e.manifest, n),
+	...e.provider === void 0 ? {} : { provider: e.provider },
+	...e.maxTokens === void 0 ? {} : { maxTokens: e.maxTokens }
+}).pipe(a.map((e) => e.object))), v = (e) => {
+	let t = [];
+	for (let n of e.tables) {
+		let e = n.columns.map((e) => `${e.name}:${e.type}${e.nullable ? "?" : ""}${e.refersTo ? `→${e.refersTo}` : ""}`).join(", ");
+		t.push(`table: ${n.name}(${e})${n.reactive ? " [reactive]" : ""}`);
+	}
+	for (let n of e.procedures) t.push(`${n.kind}: ${n.tag}`);
+	for (let n of e.workflows) t.push(`workflow: ${n.name}`);
+	return e.widgets.length > 0 && t.push(`widgets: ${e.widgets.join(", ")}`), t;
+}, y = async (e, t) => {
+	let r = await t.readManifest();
+	if (r === null) return t.log.error("voltro generate: no app.manifest.generated.json — run `voltro dev` once to emit it, then retry"), {
+		status: "rejected",
+		reason: "empty",
+		attempts: 0,
+		diagnostics: []
+	};
+	let i = v(r);
+	t.log.info(`voltro generate: ${i.length} capabilities in scope; asking the model…`);
+	let a = await f(e, { generate: t.makeGenerate(i) });
+	if (a.status !== "accepted") {
+		t.log.warn(`voltro generate: rejected (${a.reason}) after ${a.attempts} attempt(s) — nothing written`);
+		for (let e of a.diagnostics) t.log.warn(`  [${e.rule}]${e.node ? ` ${e.node}` : ""}: ${e.breaks}${e.fix ? ` → ${e.fix}` : ""}`);
+		return a;
+	}
+	let o = a.proposal.artifacts;
+	if (!t.write) {
+		t.log.info(`voltro generate: ✓ ${o.length} artifact(s) passed voltro check (dry-run — pass --write to apply):`);
+		for (let e of o) t.log.info(`  ${e.path}`);
+		return a;
+	}
+	for (let e of o) await t.writeFile(n(t.root, e.path), e.content), t.log.info(`  wrote ${e.path}`);
+	return t.log.info(`voltro generate: ✓ wrote ${o.length} artifact(s)`), a;
+}, b = async (e) => {
+	let a = e.includes("--write"), o = e.filter((e) => !e.startsWith("--")).join(" ").trim(), s = i({ scope: "voltro:generate" });
+	if (o.length === 0) return s.error("usage: voltro generate \"<prompt>\" [--write]"), 2;
+	let c = process.cwd();
+	return (await y(o, {
+		root: c,
+		write: a,
+		log: s,
+		readManifest: async () => {
+			try {
+				let e = await r.readFile(n(c, "app.manifest.generated.json"), "utf8");
+				return JSON.parse(e);
+			} catch {
+				return null;
+			}
+		},
+		makeGenerate: (e) => _({ manifest: e }),
+		writeFile: async (e, n) => {
+			await r.mkdir(t(e), { recursive: !0 }), await r.writeFile(e, n, "utf8");
+		}
+	})).status === "accepted" ? 0 : 1;
+};
+//#endregion
+export { b as runGenerateCommand };