@styx-api/core 0.5.3 → 0.6.1

package/dist/index.mjs

@@ -1242,12 +1242,17 @@ var BoutiquesParser = class {
 	wrapWithFlag(node, btInput) {
 		const flag = btInput["command-line-flag"];
 		if (!isString$2(flag)) return node;
+		const flagSep = btInput["command-line-flag-separator"];
+		const fused = isString$2(flagSep) && flagSep !== " ";
 		return {
 			kind: "sequence",
-			attrs: { nodes: [{
-				kind: "literal",
-				attrs: { str: flag + (btInput["command-line-flag-separator"] ?? "") }
-			}, node] }
+			attrs: {
+				nodes: [{
+					kind: "literal",
+					attrs: { str: fused ? flag + flagSep : flag }
+				}, node],
+				...fused && { join: "" }
+			}
 		};
 	}
 	wrapWithOptional(node) {
@@ -2762,7 +2767,7 @@ var BoutiquesEmitter = class {
 		}
 		if (peeled.flag) {
 			input["command-line-flag"] = peeled.flag;
-			if (peeled.flagSeparator) input["command-line-flag-separator"] = peeled.flagSeparator;
+			if (peeled.flagSeparator !== void 0) input["command-line-flag-separator"] = peeled.flagSeparator;
 		}
 		if (mapped.integer) input.integer = true;
 		if (mapped.minimum !== void 0) input.minimum = mapped.minimum;
@@ -2903,7 +2908,7 @@ var BoutiquesEmitter = class {
 		}
 		if (peeled.flag) {
 			input["command-line-flag"] = peeled.flag;
-			if (peeled.flagSeparator) input["command-line-flag-separator"] = peeled.flagSeparator;
+			if (peeled.flagSeparator !== void 0) input["command-line-flag-separator"] = peeled.flagSeparator;
 		}
 		if (mapped.integer) input.integer = true;
 		if (mapped.minimum !== void 0) input.minimum = mapped.minimum;
@@ -2972,9 +2977,11 @@ var BoutiquesEmitter = class {
 				const nodes = node.attrs.nodes;
 				if (nodes.length === 2 && nodes[0].kind === "literal") {
 					const flagLit = nodes[0].attrs.str;
-					const { flag, separator } = this.splitFlagLiteral(flagLit);
-					result.flag = flag;
-					if (separator) result.flagSeparator = separator;
+					if (node.attrs.join !== void 0) {
+						const { flag, separator } = this.splitFlagLiteral(flagLit);
+						result.flag = flag;
+						result.flagSeparator = separator;
+					} else result.flag = flagLit;
 					this.peelNodeInner(nodes[1], type, result);
 				}
 				break;
@@ -3495,6 +3502,10 @@ function resultToStmt$1(r) {
 	return isExpr$1(r) ? `cargs.append(${r.expr})` : r.stmt;
 }
 function appendLines$1(cb, code) {
+	if (code.trim() === "") {
+		cb.line("pass");
+		return;
+	}
 	for (const line of code.split("\n")) cb.line(line);
 }
 function toStringExpr$1(node, type, expr) {
@@ -5400,7 +5411,29 @@ function buildEmitModel(ctx, scope = new Scope(PY_RESERVED)) {
 	names.params = (rootType.kind === "struct" ? namedTypes.get(structKey(rootType)) : void 0) ?? (rootType.kind === "union" ? namedTypes.get(unionKey(rootType)) : void 0) ?? names.params;
 	const rootTypeTag = appId && pkg ? `${pkg}/${appId}` : void 0;
 	const paramsType = rootType.kind === "struct" || rootType.kind === "union" ? names.params : mapType$1(rootType, resolveTypeName(namedTypes));
+	const hostName = (childScope, wireKey) => childScope.add(pyScrubIdent(snakeCase(wireKey), PY_RESERVED));
+	const resolve = resolveTypeName(namedTypes);
 	const sigScope = scope.child(["params", "runner"]);
+	const sigEntries = rootIsStruct && rootType.kind === "struct" ? buildSigEntries(rootType, collectFieldInfo(ctx, rootType), (wireKey) => hostName(sigScope, wireKey), pySigOptions(resolve)) : [];
+	const rootStructKey = rootIsStruct && rootType.kind === "struct" ? structKey(rootType) : void 0;
+	const nestedFactories = [];
+	for (const decl of typeDecls) {
+		if (decl.type.kind !== "struct") continue;
+		const sKey = structKey(decl.type);
+		if (sKey === rootStructKey) continue;
+		const funcName = scope.add(pyScrubIdent(snakeCase(decl.name) + "_params", PY_RESERVED));
+		const atType = decl.type.fields["@type"];
+		const typeTag = atType && atType.kind === "literal" && typeof atType.value === "string" ? atType.value : void 0;
+		const factoryScope = scope.child(["params"]);
+		const factorySig = buildSigEntries(decl.type, collectFieldInfo(ctx, decl.type), (wireKey) => hostName(factoryScope, wireKey), pySigOptions(resolve));
+		nestedFactories.push({
+			typeName: decl.name,
+			structKey: sKey,
+			funcName,
+			typeTag,
+			sigEntries: factorySig
+		});
+	}
 	return {
 		appId,
 		pkg,
@@ -5411,13 +5444,14 @@ function buildEmitModel(ctx, scope = new Scope(PY_RESERVED)) {
 		typeDecls,
 		rootTypeTag,
 		paramsType,
-		sigEntries: rootIsStruct && rootType.kind === "struct" ? buildSigEntries(rootType, collectFieldInfo(ctx, rootType), (wireKey) => sigScope.add(pyScrubIdent(wireKey, PY_RESERVED)), pySigOptions(resolveTypeName(namedTypes))) : []
+		sigEntries,
+		nestedFactories
 	};
 }
 function generatePython(ctx, packageScope) {
 	const cb = new CodeBuilder("    ");
 	const scope = packageScope ?? new Scope(PY_RESERVED);
-	const { names, rootType, rootIsStruct, namedTypes, typeDecls, rootTypeTag, paramsType, sigEntries } = buildEmitModel(ctx, scope);
+	const { names, rootType, rootIsStruct, namedTypes, typeDecls, rootTypeTag, paramsType, sigEntries, nestedFactories } = buildEmitModel(ctx, scope);
 	cb.comment("This file was auto generated by Styx.", "# ");
 	cb.comment("Do not edit this file directly.", "# ");
 	cb.blank();
@@ -5436,6 +5470,10 @@ function generatePython(ctx, packageScope) {
 		emitParamsFactory$1(sigEntries, names.paramsFn, paramsType, rootTypeTag, cb);
 		cb.blank();
 	}
+	for (const nf of nestedFactories) {
+		emitParamsFactory$1(nf.sigEntries, nf.funcName, nf.typeName, nf.typeTag, cb);
+		cb.blank();
+	}
 	emitValidate$1(ctx, rootType, ctx.expr, paramsType, names.validate, resolveTypeName(namedTypes), scope, cb);
 	cb.blank();
 	emitBuildCargs$1(ctx, rootType, paramsType, names.cargs, cb);
@@ -5455,6 +5493,7 @@ function generatePython(ctx, packageScope) {
 		names.cargs,
 		...[names.outputsFn],
 		...rootIsStruct ? [names.paramsFn, names.execute] : [],
+		...nestedFactories.map((nf) => nf.funcName),
 		names.validate,
 		names.wrapper
 	];
@@ -5622,9 +5661,13 @@ function structAtType(type) {
 }
 /**
 * Render a struct config as a host object literal (Python dict / TS object).
-* Keys are the Boutiques wire names (the generated TypedDict / interface keys) -
-* nested structs have no constructor function in the generated code, so callers
-* build them as plain object literals.
+* Keys are the Boutiques wire names (the generated TypedDict / interface keys).
+*
+* When the dialect supplies `structConstructor` (Python, which generates a
+* per-struct `_params` builder), the struct is rendered as that factory call
+* instead - e.g. `tool_corrected_output_params(file="...")`. Backends without
+* per-struct builders (TypeScript) leave the hook unset and build the plain
+* object literal below.
 *
 * `@type` is emitted from the struct's literal discriminator field when present
 * (union variants carry a required, load-bearing `@type`); for the root call the
@@ -5634,6 +5677,10 @@ function structAtType(type) {
 */
 function renderStructLiteral(value, type, indent, d, injectAtType) {
 	const obj = isRecord(value) ? value : {};
+	if (injectAtType === void 0 && d.structConstructor) {
+		const call = d.structConstructor(type, obj, indent, d);
+		if (call !== void 0) return call;
+	}
 	const inner = indent + d.indentUnit;
 	const lines = [];
 	const atType = structAtType(type) ?? injectAtType;
@@ -5709,6 +5756,41 @@ const pyDialect = {
 	objKey: (k) => pyStr(k)
 };
 /**
+* Build a Python dialect that renders nested structs as `_params` factory calls
+* (matching the generated code's per-struct builders) rather than plain dicts.
+* Each factory is looked up by the struct's structural key; field values use the
+* factory's scrubbed host kwarg names (from the same `buildSigEntries` the
+* generated factory is built from), and the function name is package-qualified
+* so the call resolves through `from <root> import <pkg>`. A struct with no
+* registered factory (shouldn't happen for well-formed nested types) falls back
+* to the plain dict literal.
+*/
+function pyDialectWithFactories(model, pkg) {
+	const byKey = /* @__PURE__ */ new Map();
+	for (const f of model.nestedFactories) byKey.set(f.structKey, {
+		call: pkg ? `${pkg}.${f.funcName}` : f.funcName,
+		nameByWire: new Map(f.sigEntries.map((e) => [e.wireKey, e.name]))
+	});
+	return {
+		...pyDialect,
+		structConstructor(type, value, indent, d) {
+			const entry = byKey.get(structKey(type));
+			if (!entry) return void 0;
+			const inner = indent + d.indentUnit;
+			const lines = [];
+			for (const [wireKey, fieldType] of Object.entries(type.fields)) {
+				if (wireKey === "@type") continue;
+				if (fieldType.kind === "literal") continue;
+				if (!(wireKey in value)) continue;
+				const name = entry.nameByWire.get(wireKey) ?? wireKey;
+				lines.push(`${inner}${name}=${renderValue(value[wireKey], fieldType, inner, d)},`);
+			}
+			if (lines.length === 0) return `${entry.call}()`;
+			return `${entry.call}(\n${lines.join("\n")}\n${indent})`;
+		}
+	};
+}
+/**
 * Render a Python call snippet for one tool from a config object (the params
 * dict the form produces, keyed by Boutiques wire names).
 *
@@ -5717,8 +5799,9 @@ const pyDialect = {
 * *scrubbed host* identifiers (`float` -> `float_`), not the wire keys; the
 * per-field mapping comes from the same `buildSigEntries` the generated wrapper
 * is built from, so the snippet matches the real signature. Nested structs /
-* union variants / lists-of-structs have no constructor in the generated code,
-* so they render as plain dict literals keyed by wire names.
+* union variants / lists-of-structs render as calls to their generated
+* `_params` factory (`fsl.bet_x_params(...)`), matching the per-struct builders
+* the Python backend emits.
 *
 * Union- (or otherwise non-struct-) rooted tools have no kwarg wrapper; the
 * single dict-style `<tool>` entry is called with one object-literal argument.
@@ -5739,21 +5822,22 @@ function renderPythonCall(ctx, config, opts = {}) {
 	const model = buildEmitModel(ctx);
 	const pkg = ctx.package?.name;
 	const callee = pkg ? `${pkg}.${model.names.wrapper}` : model.names.wrapper;
-	const call = model.rootIsStruct && model.rootType.kind === "struct" ? renderKwargCall(callee, model.sigEntries, model.rootType, config) : `${callee}(${renderValue(config, model.rootType, "", pyDialect)})`;
+	const dialect = pyDialectWithFactories(model, pkg);
+	const call = model.rootIsStruct && model.rootType.kind === "struct" ? renderKwargCall(callee, model.sigEntries, model.rootType, config, dialect) : `${callee}(${renderValue(config, model.rootType, "", dialect)})`;
 	if (opts.includeImport === false || !pkg) return call;
 	const root = opts.packageRoot ?? ctx.project?.name;
 	return `${root ? `from ${root} import ${pkg}` : `import ${pkg}`}\n\n${call}`;
 }
 /** Render `callee(name=value, ...)` for a struct root using scrubbed kwarg names. */
-function renderKwargCall(callee, sigEntries, rootType, config) {
+function renderKwargCall(callee, sigEntries, rootType, config, dialect) {
 	const nameFor = new Map(sigEntries.map((e) => [e.wireKey, e.name]));
-	const indent = pyDialect.indentUnit;
+	const indent = dialect.indentUnit;
 	const lines = [];
 	for (const [wireKey, fieldType] of Object.entries(rootType.fields)) {
 		if (fieldType.kind === "literal") continue;
 		if (!(wireKey in config)) continue;
 		const name = nameFor.get(wireKey) ?? wireKey;
-		lines.push(`${indent}${name}=${renderValue(config[wireKey], fieldType, indent, pyDialect)},`);
+		lines.push(`${indent}${name}=${renderValue(config[wireKey], fieldType, indent, dialect)},`);
 	}
 	if (lines.length === 0) return `${callee}()`;
 	return `${callee}(\n${lines.join("\n")}\n)`;