@styx-api/cli 0.1.0

package/dist/write-BtRGJfHV.cjs

@@ -0,0 +1,483 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+let _styx_api_core = require("@styx-api/core");
+
+//#region src/catalog.ts
+function readJson(file) {
+	let raw;
+	try {
+		raw = (0, node_fs.readFileSync)(file, "utf8");
+	} catch (e) {
+		throw new Error(`${file}: ${e instanceof Error ? e.message : String(e)}`);
+	}
+	try {
+		return JSON.parse(raw);
+	} catch (e) {
+		throw new Error(`${file}: invalid JSON: ${e instanceof Error ? e.message : String(e)}`);
+	}
+}
+function exists(p) {
+	try {
+		(0, node_fs.statSync)(p);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function isDir(p) {
+	try {
+		return (0, node_fs.statSync)(p).isDirectory();
+	} catch {
+		return false;
+	}
+}
+function detectLevel(dir) {
+	if (exists(node_path.join(dir, "project.json"))) return "project";
+	if (exists(node_path.join(dir, "package.json"))) return "package";
+	if (exists(node_path.join(dir, "version.json"))) return "version";
+	if (exists(node_path.join(dir, "app.json"))) return "app";
+	return null;
+}
+/**
+* Load one app descriptor. When `warnings` is supplied (catalog-walk mode), a
+* stub app (`app.json` present but no `source.path`) is skipped with a warning
+* instead of aborting the whole build - real catalogs list not-yet-wrapped tools
+* alongside wrapped ones. Without `warnings` (a direct single-app target) the
+* missing source is a hard error, since the user pointed straight at it.
+*/
+function loadApp(appDir, warnings) {
+	const appJsonPath = node_path.join(appDir, "app.json");
+	if (!exists(appJsonPath)) return null;
+	const app = readJson(appJsonPath);
+	const name = app.name ?? node_path.basename(appDir);
+	const sourceRel = app.source?.path;
+	if (!sourceRel) {
+		if (warnings) {
+			warnings.push(`${appJsonPath}: skipped (no source.path - not yet wrapped)`);
+			return null;
+		}
+		throw new Error(`${appJsonPath}: missing source.path`);
+	}
+	return {
+		name,
+		sourcePath: node_path.resolve(appDir, sourceRel),
+		sourceFormat: app.source?.type
+	};
+}
+function loadVersion(versionDir, warnings) {
+	const versionPath = node_path.join(versionDir, "version.json");
+	if (!exists(versionPath)) return null;
+	const version = readJson(versionPath);
+	const appNames = version.apps ?? listSubdirs(versionDir).sort();
+	const apps = [];
+	for (const appName of appNames) {
+		const appDir = node_path.join(versionDir, appName);
+		if (!isDir(appDir)) continue;
+		const app = loadApp(appDir, warnings);
+		if (app) apps.push(app);
+	}
+	const parentPkg = node_path.join(versionDir, "..", "package.json");
+	let pkgName;
+	let pkgDoc;
+	if (exists(parentPkg)) {
+		const pkg = readJson(parentPkg);
+		pkgName = pkg.name;
+		pkgDoc = pkg.docs;
+	}
+	pkgName ??= node_path.basename(node_path.dirname(versionDir));
+	return {
+		meta: {
+			name: pkgName,
+			version: version.name,
+			docker: version.container,
+			doc: pkgDoc
+		},
+		apps
+	};
+}
+function loadPackage(pkgDir, warnings) {
+	const pkgPath = node_path.join(pkgDir, "package.json");
+	if (!exists(pkgPath)) return null;
+	const pkg = readJson(pkgPath);
+	const versionName = pkg.default ?? pkg.versions?.[0] ?? firstVersionDir(pkgDir);
+	if (!versionName) return null;
+	const versionDir = node_path.join(pkgDir, versionName);
+	if (!isDir(versionDir)) return null;
+	const loaded = loadVersion(versionDir, warnings);
+	if (!loaded) return null;
+	return {
+		meta: {
+			name: pkg.name ?? node_path.basename(pkgDir),
+			version: versionName,
+			docker: loaded.meta.docker,
+			doc: pkg.docs ?? loaded.meta.doc
+		},
+		apps: loaded.apps
+	};
+}
+function listSubdirs(dir) {
+	return (0, node_fs.readdirSync)(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+}
+function firstVersionDir(pkgDir) {
+	for (const name of listSubdirs(pkgDir)) if (exists(node_path.join(pkgDir, name, "version.json"))) return name;
+	return null;
+}
+/**
+* Load a catalog from any niwrap layout level. The level is auto-detected from
+* which `*.json` index file is present in `root`. Always returns a normalized
+* `project > package > app` shape, synthesizing missing layers as needed.
+*/
+function loadCatalog(root) {
+	const level = detectLevel(root);
+	if (!level) throw new Error(`${root}: no project.json / package.json / version.json / app.json found - not a catalog root`);
+	const warnings = [];
+	if (level === "project") {
+		const project = readJson(node_path.join(root, "project.json"));
+		const packageNames = project.packages ?? listSubdirs(root);
+		const packages = [];
+		for (const name of packageNames) {
+			const pkg = loadPackage(node_path.join(root, name), warnings);
+			if (pkg) packages.push(pkg);
+		}
+		return {
+			meta: {
+				name: project.name,
+				version: project.version,
+				doc: project.docs,
+				license: project.license ? { description: project.license } : void 0
+			},
+			packages,
+			warnings
+		};
+	}
+	if (level === "package") {
+		const pkg = loadPackage(root, warnings);
+		if (!pkg) throw new Error(`${root}: package.json present but no resolvable version`);
+		return {
+			meta: { name: pkg.meta.name },
+			packages: [pkg],
+			warnings
+		};
+	}
+	if (level === "version") {
+		const pkg = loadVersion(root, warnings);
+		if (!pkg) throw new Error(`${root}: version.json present but failed to load`);
+		return {
+			meta: { name: pkg.meta.name },
+			packages: [pkg],
+			warnings
+		};
+	}
+	const app = loadApp(root);
+	if (!app) throw new Error(`${root}: app.json present but missing source.path`);
+	return {
+		meta: {},
+		packages: [{
+			meta: { name: node_path.basename(node_path.dirname(root)) },
+			apps: [app]
+		}],
+		warnings
+	};
+}
+
+//#endregion
+//#region src/build.ts
+/** Frontend formats the compiler can parse; others are skipped with a warning. */
+const SUPPORTED_FORMATS = new Set([
+	"boutiques",
+	"argdump",
+	"workbench"
+]);
+/** Render an unknown thrown value as a message string. */
+function errMsg(e) {
+	return e instanceof Error ? e.message : String(e);
+}
+/**
+* Run the build. Returns the assembled file map and diagnostics; the caller
+* is responsible for actually writing to disk (so tests can introspect the
+* map directly).
+*/
+function build(options) {
+	if (options.input && options.catalog) return {
+		files: [],
+		errors: ["--input and --catalog are mutually exclusive"],
+		warnings: []
+	};
+	if (!options.input && !options.catalog) return {
+		files: [],
+		errors: ["missing input: pass a descriptor path or --catalog"],
+		warnings: []
+	};
+	if (options.input) return buildSingle(options.input, options);
+	return buildCatalog(options.catalog, options);
+}
+function buildSingle(inputPath, options) {
+	const result = {
+		files: [],
+		errors: [],
+		warnings: []
+	};
+	const ctx = readAndCompile(inputPath, void 0, void 0, void 0, result);
+	if (!ctx) return result;
+	for (const backend of options.backends) {
+		let emitted;
+		try {
+			emitted = backend.emitApp(ctx);
+		} catch (e) {
+			result.errors.push(`[${backend.name}] ${errMsg(e)}`);
+			continue;
+		}
+		appendEmitMessages(result, emitted, backend);
+		for (const [name, content] of emitted.files) result.files.push({
+			path: node_path.resolve(options.out, backend.target, name),
+			content
+		});
+	}
+	return result;
+}
+function buildCatalog(catalogPath, options) {
+	const result = {
+		files: [],
+		errors: [],
+		warnings: [],
+		stats: {
+			appsCompiled: 0,
+			appsFailed: 0,
+			appsSkipped: 0
+		}
+	};
+	let catalog;
+	try {
+		catalog = loadCatalog(catalogPath);
+	} catch (e) {
+		result.errors.push(e instanceof Error ? e.message : String(e));
+		return result;
+	}
+	result.warnings.push(...catalog.warnings);
+	options.backends.forEach((backend, i) => {
+		runBackendOverCatalog(backend, catalog, options.mode, options.out, result, i === 0);
+	});
+	return result;
+}
+/**
+* Parse a descriptor, run the default optimization pipeline, solve to
+* bindings, and build a `CodegenContext` wired up with the supplied
+* package/project meta. Returns null on read failure (with the error already
+* appended to `result`). Parse-level errors/warnings are also appended.
+*/
+function readAndCompile(sourcePath, format, pkg, proj, result) {
+	let source;
+	try {
+		source = (0, node_fs.readFileSync)(sourcePath, "utf8");
+	} catch (e) {
+		result.errors.push(`${sourcePath}: ${errMsg(e)}`);
+		return null;
+	}
+	try {
+		const parsed = (0, _styx_api_core.compile)(source, format && SUPPORTED_FORMATS.has(format) ? {
+			filename: sourcePath,
+			format
+		} : sourcePath);
+		for (const e of parsed.errors) result.errors.push(`${sourcePath}: ${e.message}`);
+		for (const w of parsed.warnings) result.warnings.push(`${sourcePath}: ${w.message}`);
+		const piped = _styx_api_core.defaultPipeline.apply(parsed.expr);
+		if (piped.warnings) for (const w of piped.warnings) result.warnings.push(`${sourcePath}: ${w}`);
+		const solveResult = (0, _styx_api_core.solve)(piped.expr);
+		const outputs = (0, _styx_api_core.resolveOutputs)(piped.expr, solveResult);
+		return (0, _styx_api_core.createContext)(piped.expr, solveResult, outputs, {
+			app: parsed.meta,
+			package: pkg,
+			project: proj
+		});
+	} catch (e) {
+		result.errors.push(`${sourcePath}: ${errMsg(e)}`);
+		return null;
+	}
+}
+function runBackendOverCatalog(backend, catalog, mode, outRoot, result, recordWarnings) {
+	const backendRoot = node_path.resolve(outRoot, backend.target);
+	const packagesEmitted = [];
+	for (const pkg of catalog.packages) {
+		const pkgDir = pkg.meta.name ?? "package";
+		const appsEmitted = [];
+		let skipped = 0;
+		const pkgScope = backend.newPackageScope?.();
+		for (const app of pkg.apps) {
+			if (app.sourceFormat && !SUPPORTED_FORMATS.has(app.sourceFormat)) {
+				skipped++;
+				if (recordWarnings) {
+					if (result.stats) result.stats.appsSkipped++;
+					result.warnings.push(`${app.sourcePath}: skipped (unsupported source format "${app.sourceFormat}")`);
+				}
+				continue;
+			}
+			const ctx = readAndCompile(app.sourcePath, app.sourceFormat, pkg.meta, catalog.meta, result);
+			if (!ctx) {
+				if (recordWarnings && result.stats) result.stats.appsFailed++;
+				continue;
+			}
+			let emitted;
+			try {
+				emitted = backend.emitApp(ctx, pkgScope);
+			} catch (e) {
+				result.errors.push(`[${backend.name} ${pkg.meta.name}/${app.name}] ${errMsg(e)}`);
+				if (recordWarnings && result.stats) result.stats.appsFailed++;
+				continue;
+			}
+			appendEmitMessages(result, emitted, backend, `${pkg.meta.name}/${app.name}`);
+			appsEmitted.push(emitted);
+			if (recordWarnings && result.stats) result.stats.appsCompiled++;
+			for (const [name, content] of emitted.files) result.files.push({
+				path: node_path.join(backendRoot, pkgDir, name),
+				content
+			});
+		}
+		if (appsEmitted.length === 0) {
+			if (recordWarnings && skipped > 0 && skipped === pkg.apps.length) result.warnings.push(`${pkgDir}: all ${skipped} tool(s) skipped, package omitted`);
+			continue;
+		}
+		if (mode !== "scripts" && backend.emitPackage) try {
+			const pkgEmit = backend.emitPackage(pkg.meta, appsEmitted);
+			appendEmitMessages(result, pkgEmit, backend, pkg.meta.name);
+			packagesEmitted.push(pkgEmit);
+			for (const [name, content] of pkgEmit.files) result.files.push({
+				path: node_path.join(backendRoot, pkgDir, name),
+				content
+			});
+		} catch (e) {
+			result.errors.push(`[${backend.name} ${pkgDir}] package emit failed: ${errMsg(e)}`);
+		}
+	}
+	if (mode === "multi" && backend.emitProject && packagesEmitted.length > 0) try {
+		const projEmit = backend.emitProject(catalog.meta, packagesEmitted);
+		appendEmitMessages(result, projEmit, backend, catalog.meta.name);
+		for (const [name, content] of projEmit.files) result.files.push({
+			path: node_path.join(backendRoot, name),
+			content
+		});
+	} catch (e) {
+		result.errors.push(`[${backend.name}] project emit failed: ${errMsg(e)}`);
+	}
+}
+function appendEmitMessages(result, emit, backend, scope) {
+	const tag = scope ? `[${backend.name} ${scope}]` : `[${backend.name}]`;
+	for (const e of emit.errors) result.errors.push(`${tag} ${e.message}`);
+	for (const w of emit.warnings) result.warnings.push(`${tag} ${w.message}`);
+}
+
+//#endregion
+//#region src/backends.ts
+/**
+* Registry of backends keyed by CLI alias. The alias is what users pass to
+* `-b`; the backend's `name`/`target` is what we use for the output subdir.
+*/
+const registry = {
+	python: () => new _styx_api_core.PythonBackend(),
+	typescript: () => new _styx_api_core.TypeScriptBackend(),
+	ts: () => new _styx_api_core.TypeScriptBackend(),
+	schema: () => new _styx_api_core.JsonSchemaBackend(),
+	"json-schema": () => new _styx_api_core.JsonSchemaBackend(),
+	boutiques: () => new _styx_api_core.BoutiquesBackend()
+};
+const knownBackends = Object.keys(registry);
+function resolveBackends(names) {
+	const backends = [];
+	const seen = /* @__PURE__ */ new Set();
+	const unknown = [];
+	for (const name of names) {
+		const factory = registry[name];
+		if (!factory) {
+			unknown.push(name);
+			continue;
+		}
+		const backend = factory();
+		if (seen.has(backend.name)) continue;
+		seen.add(backend.name);
+		backends.push(backend);
+	}
+	return {
+		backends,
+		unknown
+	};
+}
+
+//#endregion
+//#region src/write.ts
+function writeFiles(files) {
+	for (const file of files) {
+		(0, node_fs.mkdirSync)(node_path.dirname(file.path), { recursive: true });
+		(0, node_fs.writeFileSync)(file.path, file.content, "utf8");
+	}
+}
+
+//#endregion
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
+Object.defineProperty(exports, 'build', {
+  enumerable: true,
+  get: function () {
+    return build;
+  }
+});
+Object.defineProperty(exports, 'detectLevel', {
+  enumerable: true,
+  get: function () {
+    return detectLevel;
+  }
+});
+Object.defineProperty(exports, 'knownBackends', {
+  enumerable: true,
+  get: function () {
+    return knownBackends;
+  }
+});
+Object.defineProperty(exports, 'loadCatalog', {
+  enumerable: true,
+  get: function () {
+    return loadCatalog;
+  }
+});
+Object.defineProperty(exports, 'resolveBackends', {
+  enumerable: true,
+  get: function () {
+    return resolveBackends;
+  }
+});
+Object.defineProperty(exports, 'writeFiles', {
+  enumerable: true,
+  get: function () {
+    return writeFiles;
+  }
+});