@zodmire/cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026-present Vercel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/zodmire.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../mod.mjs";

package/mod.d.mts

@@ -0,0 +1 @@
+export { };

package/mod.mjs

@@ -0,0 +1,299 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+import { VENDORED_FILE_MANIFEST, buildCompositionArtifacts, buildContextNormalizedSpecFromConfig, buildFileArtifactTags, buildNormalizedCompositionSpec, buildNormalizedSpecTags, buildV5ContextArtifacts, filterPerContextArtifactsForComposition, inferReconcileScopes, mergeGeneratedArtifacts, prepareAllVendoredFiles, resolveAbsoluteContextInputs, serializeCompositionSpec, serializeContextSpec } from "@zodmire/core";
+import { materializeOwnedArtifacts } from "@zodmire/core/materialize";
+import { statSync } from "node:fs";
+import { spawn } from "node:child_process";
+
+//#region packages/cli/version.ts
+const GENERATOR_VERSION = "2026.03.26.1";
+
+//#endregion
+//#region packages/cli/init.ts
+function resolveSourcePath(relativePath) {
+	return `${`${dirname(fileURLToPath(import.meta.url))}/../..`}/${relativePath}`;
+}
+async function runInit(targetDir) {
+	const sourceContents = /* @__PURE__ */ new Map();
+	for (const entry of VENDORED_FILE_MANIFEST) {
+		const path = resolveSourcePath(entry.sourceRelativePath);
+		sourceContents.set(entry.sourceRelativePath, await readFile(path, "utf-8"));
+	}
+	const prepared = prepareAllVendoredFiles(sourceContents, GENERATOR_VERSION);
+	await mkdir(targetDir, { recursive: true });
+	for (const file of prepared) {
+		const destPath = `${targetDir}/${file.outputName}`;
+		await writeFile(destPath, file.content, "utf-8");
+		console.log(`  wrote ${destPath}`);
+	}
+	console.log(`\nInit complete. ${prepared.length} files written to ${targetDir}`);
+}
+
+//#endregion
+//#region packages/cli/version_data.ts
+function isSwampRepoAvailable(basePath = ".") {
+	try {
+		return statSync(resolve(basePath, ".swamp")).isDirectory();
+	} catch {
+		return false;
+	}
+}
+function spawnSwampDataPut(args, stdinContent) {
+	return new Promise((resolve, reject) => {
+		const proc = spawn("swamp", args, { stdio: [
+			"pipe",
+			"ignore",
+			"pipe"
+		] });
+		let stderr = "";
+		proc.stderr.on("data", (chunk) => {
+			stderr += chunk.toString();
+		});
+		proc.on("close", (code) => {
+			if (code !== 0) reject(/* @__PURE__ */ new Error(`swamp data put failed: ${stderr}`));
+			else resolve();
+		});
+		proc.stdin.write(stdinContent);
+		proc.stdin.end();
+	});
+}
+async function mirrorToSwampDataLayer(opts) {
+	const { modelName, artifacts, specJson, specDataName, generatorVersion, generationRunId, methodName, basis, contextName, compositionName, producer, producerName } = opts;
+	for (const artifact of artifacts) {
+		const tagArgs = Object.entries(buildFileArtifactTags({
+			logicalPath: artifact.logicalPath,
+			generatorVersion,
+			generationRunId,
+			methodName,
+			producer,
+			producerName,
+			basis,
+			contextName,
+			compositionName,
+			ownershipScope: artifact.ownershipScope,
+			scopeKey: artifact.scopeKey
+		})).map(([key, value]) => `${key}=${value}`).flatMap((t) => ["--tag", t]);
+		await spawnSwampDataPut([
+			"data",
+			"put",
+			modelName,
+			artifact.dataName,
+			"--content-type",
+			"text/plain",
+			...tagArgs
+		], artifact.content);
+	}
+	if (specJson !== void 0 && specDataName !== void 0) await spawnSwampDataPut([
+		"data",
+		"put",
+		modelName,
+		specDataName,
+		"--content-type",
+		"application/json",
+		...Object.entries(buildNormalizedSpecTags({
+			generatorVersion,
+			generationRunId,
+			methodName,
+			producer,
+			producerName,
+			basis,
+			contextName,
+			compositionName
+		})).map(([key, value]) => `${key}=${value}`).flatMap((t) => ["--tag", t])
+	], specJson);
+}
+
+//#endregion
+//#region packages/cli/generate.ts
+async function runGenerate(opts) {
+	const configPath = opts.configPath.startsWith("/") ? opts.configPath : `${process.cwd()}/${opts.configPath}`;
+	if (opts.composition) await runCompositionGenerate(configPath, opts.targetOverride, opts.versionData);
+	else await runContextGenerate(configPath, opts.targetOverride, opts.versionData);
+}
+async function runContextGenerate(configPath, targetOverride, versionData) {
+	const resolvedInputs = await resolveAbsoluteContextInputs(configPath);
+	const config = resolvedInputs.config;
+	const codegenSupportPath = resolvedInputs.codegenSupportPath;
+	console.log(`Generating context from ${configPath}`);
+	console.log(`  codegen support: ${codegenSupportPath}`);
+	const artifacts = await buildV5ContextArtifacts({
+		contextConfigPath: configPath,
+		codegenSupportPath
+	});
+	const targetRoot = targetOverride ?? config.materialization?.targetRoot;
+	if (!targetRoot) throw new Error("No --target specified and context config has no materialization.targetRoot");
+	const resolvedTarget = targetRoot.startsWith("/") ? targetRoot : `${process.cwd()}/${targetRoot}`;
+	console.log(`  target: ${resolvedTarget}`);
+	const result = await materializeOwnedArtifacts(resolvedTarget, artifacts, GENERATOR_VERSION, { reconcileScopes: inferReconcileScopes(artifacts) });
+	if (versionData) {
+		if (!isSwampRepoAvailable()) throw new Error("Swamp repo not initialized. Run `swamp init` or omit --version-data");
+		const contextSpec = await buildContextNormalizedSpecFromConfig({
+			contextConfigPath: configPath,
+			codegenSupportPath
+		});
+		const specJson = serializeContextSpec(contextSpec, GENERATOR_VERSION);
+		const generationRunId = `run-${(/* @__PURE__ */ new Date()).toISOString()}-${crypto.randomUUID().slice(0, 8)}`;
+		console.log("  mirroring to Swamp data layer...");
+		await mirrorToSwampDataLayer({
+			modelName: "codegen",
+			artifacts: artifacts.map((a) => ({
+				logicalPath: a.logicalPath,
+				dataName: a.logicalPath.replace(/\//g, ":"),
+				content: a.content,
+				ownershipScope: a.ownershipScope,
+				scopeKey: a.scopeKey
+			})),
+			specJson,
+			specDataName: `context-normalized-spec:${contextSpec.context.modulePath}`,
+			generatorVersion: GENERATOR_VERSION,
+			generationRunId,
+			methodName: "generate",
+			basis: "context",
+			contextName: contextSpec.context.name,
+			producer: "cli",
+			producerName: "zodmire"
+		});
+		console.log("  mirrored to Swamp data layer");
+	}
+	console.log(`\nMaterialized ${result.files.length} files to ${result.targetRoot}`);
+}
+async function runCompositionGenerate(compositionConfigPath, targetOverride, versionData) {
+	const compositionConfig = (await import(new URL(compositionConfigPath, "file:///").href)).default;
+	const targetRoot = targetOverride ?? compositionConfig.materialization?.targetRoot;
+	if (!targetRoot) throw new Error("No --target specified and composition config has no materialization.targetRoot");
+	const resolvedTarget = targetRoot.startsWith("/") ? targetRoot : `${process.cwd()}/${targetRoot}`;
+	if (!compositionConfig.contextConfigs || compositionConfig.contextConfigs.length === 0) throw new Error("Composition config must include contextConfigs array with { contextConfigPath, codegenSupportPath } entries");
+	const compositionDir = compositionConfigPath.substring(0, compositionConfigPath.lastIndexOf("/") + 1);
+	const resolvedContextConfigs = compositionConfig.contextConfigs.map((cfg) => ({
+		contextConfigPath: cfg.contextConfigPath.startsWith("/") ? cfg.contextConfigPath : compositionDir + cfg.contextConfigPath.replace(/^\.\//, ""),
+		codegenSupportPath: cfg.codegenSupportPath.startsWith("/") ? cfg.codegenSupportPath : compositionDir + cfg.codegenSupportPath.replace(/^\.\//, "")
+	}));
+	console.log(`Generating composition from ${compositionConfigPath}`);
+	console.log(`  contexts: ${resolvedContextConfigs.length}`);
+	const contextSpecs = await Promise.all(resolvedContextConfigs.map((cfg) => buildContextNormalizedSpecFromConfig(cfg)));
+	const perContextArtifacts = await Promise.all(resolvedContextConfigs.map((cfg) => buildV5ContextArtifacts(cfg)));
+	const compositionArtifacts = await buildCompositionArtifacts(compositionConfigPath, contextSpecs);
+	const allArtifacts = mergeGeneratedArtifacts(...perContextArtifacts.map(filterPerContextArtifactsForComposition), compositionArtifacts).sort((a, b) => a.logicalPath.localeCompare(b.logicalPath));
+	console.log(`  target: ${resolvedTarget}`);
+	const result = await materializeOwnedArtifacts(resolvedTarget, allArtifacts, GENERATOR_VERSION, { reconcileScopes: inferReconcileScopes(allArtifacts) });
+	if (versionData) {
+		if (!isSwampRepoAvailable()) throw new Error("Swamp repo not initialized. Run `swamp init` or omit --version-data");
+		const compositionSpec = buildNormalizedCompositionSpec(compositionConfig, contextSpecs);
+		const specJson = serializeCompositionSpec(compositionSpec, GENERATOR_VERSION);
+		const generationRunId = `run-${(/* @__PURE__ */ new Date()).toISOString()}-${crypto.randomUUID().slice(0, 8)}`;
+		console.log("  mirroring to Swamp data layer...");
+		await mirrorToSwampDataLayer({
+			modelName: "codegen",
+			artifacts: allArtifacts.map((a) => ({
+				logicalPath: a.logicalPath,
+				dataName: a.logicalPath.replace(/\//g, ":"),
+				content: a.content,
+				ownershipScope: a.ownershipScope,
+				scopeKey: a.scopeKey
+			})),
+			specJson,
+			specDataName: `composition-normalized-spec:${compositionSpec.name}`,
+			generatorVersion: GENERATOR_VERSION,
+			generationRunId,
+			methodName: "compose",
+			basis: "composition",
+			compositionName: compositionSpec.name,
+			producer: "cli",
+			producerName: "zodmire"
+		});
+		console.log("  mirrored to Swamp data layer");
+	}
+	console.log(`\nMaterialized ${result.files.length} files to ${result.targetRoot}`);
+}
+
+//#endregion
+//#region packages/cli/mod.ts
+function printUsage() {
+	console.log(`zodmire v${GENERATOR_VERSION}
+
+Usage:
+  zodmire init --target <dir>
+  zodmire generate --config <path> [--composition] [--target <dir>] [--version-data]
+  zodmire --version
+  zodmire --help
+
+Commands:
+  init        Scaffold codegen helper files into your project
+  generate    Generate a bounded context skeleton from Zod schemas
+
+Options:
+  --target        For init: directory to write helpers into
+                  For generate: override materialization target directory
+  --config        Path to context config (.context.ts) or composition config
+  --composition   Treat --config as a composition config (multi-context)
+  --version-data  Mirror artifacts to Swamp data layer (requires .swamp/ repo)
+  --version       Print version
+  --help          Print this help
+`);
+}
+function parseArgs(args) {
+	const command = args[0] && !args[0].startsWith("--") ? args[0] : "";
+	const flags = {};
+	const startIdx = command ? 1 : 0;
+	for (let i = startIdx; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--composition") flags.composition = true;
+		else if (arg === "--version-data") flags["version-data"] = true;
+		else if (arg.startsWith("--") && i + 1 < args.length && !args[i + 1].startsWith("--")) {
+			flags[arg.slice(2)] = args[i + 1];
+			i++;
+		} else if (arg.startsWith("--")) flags[arg.slice(2)] = true;
+	}
+	return {
+		command,
+		flags
+	};
+}
+async function main() {
+	const { command, flags } = parseArgs(process.argv.slice(2));
+	if (flags.version) {
+		console.log(GENERATOR_VERSION);
+		return;
+	}
+	if (flags.help || !command) {
+		printUsage();
+		return;
+	}
+	switch (command) {
+		case "init": {
+			const target = flags.target;
+			if (typeof target !== "string") {
+				console.error("Error: --target <dir> is required for init");
+				process.exit(1);
+			}
+			await runInit(target);
+			break;
+		}
+		case "generate": {
+			const config = flags.config;
+			if (typeof config !== "string") {
+				console.error("Error: --config <path> is required for generate");
+				process.exit(1);
+			}
+			await runGenerate({
+				configPath: config,
+				composition: flags.composition === true,
+				targetOverride: typeof flags.target === "string" ? flags.target : void 0,
+				versionData: flags["version-data"] === true
+			});
+			break;
+		}
+		default:
+			console.error(`Unknown command: ${command}`);
+			printUsage();
+			process.exit(1);
+	}
+}
+main().catch((err) => {
+	console.error(`Error: ${err.message}`);
+	process.exit(1);
+});
+
+//#endregion
+export {  };

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@zodmire/cli",
+  "version": "0.1.0",
+  "license": "MIT",
+  "type": "module",
+  "main": "./mod.mjs",
+  "module": "./mod.mjs",
+  "types": "./mod.d.mts",
+  "exports": {
+    ".": {
+      "types": "./mod.d.mts",
+      "import": "./mod.mjs"
+    }
+  },
+  "dependencies": {
+    "@zodmire/config": "^0.1.0",
+    "@zodmire/core": "^0.1.0"
+  },
+  "bin": {
+    "zodmire": "./bin/zodmire.js"
+  }
+}