@openpolicy/cli 0.0.10 → 0.0.11

package/README.md

@@ -41,6 +41,7 @@ openpolicy generate ./terms.config.ts   --format markdown      --out ./public/po
 | `--format` | `markdown` | Comma-separated output formats: `markdown`, `html` |
 | `--out` | `./public/policies` | Output directory |
 | `--type` | auto-detected | Override policy type: `privacy` or `terms` |
+| `--watch` | `false` | Watch config files and regenerate on changes |
 
 Policy type is auto-detected from the filename — files containing `"terms"` compile as terms of service.
 

package/dist/cli.js

@@ -2,9 +2,9 @@
 import { defineCommand, runMain } from "citty";
 import { join, resolve } from "node:path";
 import consola from "consola";
-import { access, mkdir, writeFile } from "node:fs/promises";
-import { compilePolicy, validatePrivacyPolicy, validateTermsOfService } from "@openpolicy/core";
-import { existsSync } from "node:fs";
+import { existsSync, watch } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { compilePolicy, expandOpenPolicyConfig, isOpenPolicyConfig, validatePrivacyPolicy, validateTermsOfService } from "@openpolicy/core";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -18,6 +18,9 @@ var __exportAll = (all, no_symbols) => {
 	return target;
 };
 //#endregion
+//#region package.json
+var version = "0.0.11";
+//#endregion
 //#region src/commands/init.ts
 var init_exports = /* @__PURE__ */ __exportAll({ initCommand: () => initCommand });
 function toJurisdictions(choice) {
@@ -267,21 +270,25 @@ var init_init = __esmMin((() => {
 //#endregion
 //#region src/utils/detect-type.ts
 function detectType(explicitType, configPath) {
-	if (explicitType === "privacy" || explicitType === "terms") return explicitType;
-	return configPath.toLowerCase().includes("terms") ? "terms" : "privacy";
+	if (explicitType === "privacy" || explicitType === "terms" || explicitType === "cookie") return explicitType;
+	const lower = configPath.toLowerCase();
+	if (lower.includes("cookie")) return "cookie";
+	if (lower.includes("terms")) return "terms";
+	return "privacy";
 }
 var init_detect_type = __esmMin((() => {}));
 //#endregion
 //#region src/utils/load-config.ts
-async function loadConfig(configPath) {
+async function loadConfig(configPath, bustCache = false) {
 	const absPath = resolve(configPath);
 	if (!existsSync(absPath)) {
 		consola.error(`Config file not found: ${absPath}`);
 		process.exit(1);
 	}
+	const importPath = bustCache ? `${absPath}?t=${Date.now()}` : absPath;
 	let mod;
 	try {
-		mod = await import(absPath);
+		mod = await import(importPath);
 	} catch (err) {
 		consola.error(`Failed to load config: ${absPath}`);
 		consola.error(err);
@@ -298,6 +305,54 @@ var init_load_config = __esmMin((() => {}));
 //#endregion
 //#region src/commands/generate.ts
 var generate_exports = /* @__PURE__ */ __exportAll({ generateCommand: () => generateCommand });
+function toPolicyInput(policyType, config) {
+	if (policyType === "terms") return {
+		type: "terms",
+		...config
+	};
+	if (policyType === "cookie") return {
+		type: "cookie",
+		...config
+	};
+	return {
+		type: "privacy",
+		...config
+	};
+}
+async function generateFromConfig(configPath, formats, outDir, explicitType, bustCache = false) {
+	if (!existsSync(configPath)) return false;
+	const config = await loadConfig(configPath, bustCache);
+	if (isOpenPolicyConfig(config)) {
+		const inputs = expandOpenPolicyConfig(config);
+		if (inputs.length === 0) {
+			consola.warn(`Unified config has no privacy or terms sections: ${configPath}`);
+			return true;
+		}
+		await mkdir(outDir, { recursive: true });
+		for (const input of inputs) {
+			const outputFilename = input.type === "terms" ? "terms-of-service" : input.type === "cookie" ? "cookie-policy" : "privacy-policy";
+			consola.start(`Generating ${input.type} policy from ${configPath} → formats: ${formats.join(", ")}`);
+			const results = compilePolicy(input, { formats });
+			for (const result of results) {
+				const outPath = join(outDir, `${outputFilename}.${result.format === "markdown" ? "md" : result.format}`);
+				await writeFile(outPath, result.content, "utf-8");
+				consola.success(`Written: ${outPath}`);
+			}
+		}
+		return true;
+	}
+	const policyType = detectType(explicitType, configPath);
+	consola.start(`Generating ${policyType} policy from ${configPath} → formats: ${formats.join(", ")}`);
+	const outputFilename = policyType === "terms" ? "terms-of-service" : policyType === "cookie" ? "cookie-policy" : "privacy-policy";
+	const results = compilePolicy(toPolicyInput(policyType, config), { formats });
+	await mkdir(outDir, { recursive: true });
+	for (const result of results) {
+		const outPath = join(outDir, `${outputFilename}.${result.format === "markdown" ? "md" : result.format}`);
+		await writeFile(outPath, result.content, "utf-8");
+		consola.success(`Written: ${outPath}`);
+	}
+	return true;
+}
 var generateCommand;
 var init_generate = __esmMin((() => {
 	init_detect_type();
@@ -311,7 +366,7 @@ var init_generate = __esmMin((() => {
 			config: {
 				type: "positional",
 				description: "Path(s) to policy config file(s), comma-separated",
-				default: "./policy.config.ts,./terms.config.ts"
+				default: "./openpolicy.ts,./policy.config.ts,./terms.config.ts"
 			},
 			format: {
 				type: "string",
@@ -325,42 +380,42 @@ var init_generate = __esmMin((() => {
 			},
 			type: {
 				type: "string",
-				description: "Policy type: \"privacy\" or \"terms\" (auto-detected from filename if omitted)",
+				description: "Policy type: \"privacy\", \"terms\", or \"cookie\" (auto-detected from filename if omitted)",
 				default: ""
+			},
+			watch: {
+				type: "boolean",
+				description: "Watch config files and regenerate on changes",
+				default: false
 			}
 		},
 		async run({ args }) {
-			const formats = (args.format ?? "markdown").split(",").map((f) => f.trim()).filter(Boolean);
-			const outDir = args.out ?? "./output";
-			const configPaths = (args.config ?? "./policy.config.ts,./terms.config.ts").split(",").map((p) => p.trim()).filter(Boolean);
-			const isMulti = configPaths.length > 1;
-			for (const configPath of configPaths) {
-				if (!await access(configPath).then(() => true).catch(() => false)) {
-					if (isMulti) {
-						consola.warn(`Config not found, skipping: ${configPath}`);
-						continue;
-					}
-					throw new Error(`Config not found: ${configPath}`);
-				}
-				const policyType = detectType(args.type || void 0, configPath);
-				consola.start(`Generating ${policyType} policy from ${configPath} → formats: ${formats.join(", ")}`);
-				const config = await loadConfig(configPath);
-				const outputFilename = policyType === "terms" ? "terms-of-service" : "privacy-policy";
-				const results = compilePolicy(policyType === "terms" ? {
-					type: "terms",
-					...config
-				} : {
-					type: "privacy",
-					...config
-				}, { formats });
-				await mkdir(outDir, { recursive: true });
-				for (const result of results) {
-					const outPath = join(outDir, `${outputFilename}.${result.format === "markdown" ? "md" : result.format}`);
-					await writeFile(outPath, result.content, "utf-8");
-					consola.success(`Written: ${outPath}`);
+			const formats = args.format.split(",").map((f) => f.trim()).filter(Boolean);
+			const outDir = args.out;
+			const explicitType = args.type || void 0;
+			const configPaths = args.config.split(",").map((p) => p.trim()).filter(Boolean);
+			const hasMultipleConfigs = configPaths.length > 1;
+			const watchablePaths = [];
+			for (const configPath of configPaths) if (await generateFromConfig(configPath, formats, outDir, explicitType)) watchablePaths.push(configPath);
+			else if (hasMultipleConfigs) consola.warn(`Config not found, skipping: ${configPath}`);
+			else throw new Error(`Config not found: ${configPath}`);
+			consola.success(`Policy generation complete → ${outDir}`);
+			if (args.watch && watchablePaths.length > 0) {
+				consola.info("Watching for changes...");
+				for (const configPath of watchablePaths) {
+					let debounceTimer = null;
+					watch(configPath, () => {
+						if (debounceTimer) clearTimeout(debounceTimer);
+						debounceTimer = setTimeout(async () => {
+							try {
+								await generateFromConfig(configPath, formats, outDir, explicitType, true);
+							} catch (err) {
+								consola.error(`Error regenerating ${configPath}:`, err);
+							}
+						}, 100);
+					});
 				}
 			}
-			consola.success(`Policy generation complete → ${outDir}`);
 		}
 	});
 }));
@@ -419,7 +474,7 @@ var init_validate = __esmMin((() => {
 runMain(defineCommand({
 	meta: {
 		name: "openpolicy",
-		version: "0.0.1",
+		version,
 		description: "Generate and validate privacy policy documents"
 	},
 	subCommands: {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@openpolicy/cli",
-	"version": "0.0.10",
+	"version": "0.0.11",
 	"type": "module",
 	"description": "CLI for generating and validating OpenPolicy privacy policy documents",
 	"license": "MIT",