@openpolicy/cli 0.0.10 → 0.0.12

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

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import { defineCommand, runMain } from "citty";
+import { mkdir, writeFile } from "node:fs/promises";
 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 { compilePolicy, expandOpenPolicyConfig, isOpenPolicyConfig, validateCookiePolicy, validatePrivacyPolicy, validateTermsOfService } from "@openpolicy/core";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -18,270 +18,121 @@ var __exportAll = (all, no_symbols) => {
 	return target;
 };
 //#endregion
+//#region package.json
+var version = "0.0.12";
+//#endregion
 //#region src/commands/init.ts
-var init_exports = /* @__PURE__ */ __exportAll({ initCommand: () => initCommand });
-function toJurisdictions(choice) {
-	if (choice === "gdpr") return ["eu"];
-	if (choice === "ccpa") return ["ca"];
-	if (choice === "both") return ["eu", "ca"];
-	return ["us"];
-}
-function toDataCollected(categories) {
-	const groups = {};
-	for (const cat of categories) {
-		const mapping = DATA_CATEGORY_MAP[cat];
-		if (!mapping) continue;
-		groups[mapping.group] = [...groups[mapping.group] ?? [], mapping.label];
-	}
-	return Object.keys(groups).length > 0 ? groups : { "Personal Information": ["Email address"] };
-}
-function toUserRights(jurisdictions) {
-	const rights = new Set(["access", "erasure"]);
-	if (jurisdictions.includes("eu")) for (const r of [
-		"rectification",
-		"portability",
-		"restriction",
-		"objection"
-	]) rights.add(r);
-	if (jurisdictions.includes("ca")) for (const r of ["opt_out_sale", "non_discrimination"]) rights.add(r);
-	return Array.from(rights);
-}
-function renderPrivacyConfig(values) {
-	const dataLines = Object.entries(values.dataCollected).map(([k, v]) => `    ${JSON.stringify(k)}: ${JSON.stringify(v)},`).join("\n");
-	return `import { definePrivacyPolicy } from "@openpolicy/sdk";
-
-export default definePrivacyPolicy({
-  effectiveDate: "${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}",
-  company: {
-    name: ${JSON.stringify(values.companyName)},
-    legalName: ${JSON.stringify(values.legalName)},
-    address: ${JSON.stringify(values.address)},
-    contact: ${JSON.stringify(values.contact)},
-  },
-  dataCollected: {
-${dataLines}
-  },
-  legalBasis: ${JSON.stringify(values.legalBasis)},
-  retention: {
-    "All personal data": "As long as necessary for the purposes described in this policy",
-  },
-  cookies: {
-    essential: true,
-    analytics: ${values.hasCookies},
-    marketing: false,
-  },
-  thirdParties: [],
-  userRights: ${JSON.stringify(values.userRights)},
-  jurisdictions: ${JSON.stringify(values.jurisdictions)},
+var init_exports = /* @__PURE__ */ __exportAll({
+	getOpenPolicyTemplate: () => getOpenPolicyTemplate,
+	initCommand: () => initCommand
 });
-`;
-}
-function renderTermsConfig(values) {
-	return `import { defineTermsOfService } from "@openpolicy/sdk";
+function getOpenPolicyTemplate(companyName, contactEmail, policies) {
+	const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+	return `import { defineConfig } from "@openpolicy/sdk";
 
-export default defineTermsOfService({
-  effectiveDate: "${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}",
-  company: {
-    name: ${JSON.stringify(values.companyName)},
-    legalName: ${JSON.stringify(values.legalName)},
-    address: ${JSON.stringify(values.address)},
-    contact: ${JSON.stringify(values.contact)},
-  },
-  acceptance: {
-    methods: ["using the service", "creating an account"],
-  },
-  eligibility: {
-    minimumAge: 13,
-  },
-  accounts: {
-    registrationRequired: false,
-    userResponsibleForCredentials: true,
-    companyCanTerminate: true,
-  },
-  prohibitedUses: [
-    "Violating any applicable laws or regulations",
-    "Infringing on intellectual property rights",
-    "Transmitting harmful or malicious content",
-  ],
-  intellectualProperty: {
-    companyOwnsService: true,
-    usersMayNotCopy: true,
-  },
-  termination: {
-    companyCanTerminate: true,
-    userCanTerminate: true,
-  },
-  disclaimers: {
-    serviceProvidedAsIs: true,
-    noWarranties: true,
-  },
-  limitationOfLiability: {
-    excludesIndirectDamages: true,
-  },
-  governingLaw: {
-    jurisdiction: ${JSON.stringify(values.jurisdiction)},
-  },
-  changesPolicy: {
-    noticeMethod: "email or prominent notice on our website",
-    noticePeriodDays: 30,
-  },
-});
-`;
-}
-var DATA_CATEGORY_MAP, initCommand;
-var init_init = __esmMin((() => {
-	DATA_CATEGORY_MAP = {
-		name: {
-			group: "Personal Information",
-			label: "Full name"
+export default defineConfig({
+	company: {
+		name: "${companyName}",
+		legalName: "${companyName}",
+		address: "",
+		contact: "${contactEmail}",
+	},${policies.includes("privacy") ? `
+	privacy: {
+		effectiveDate: "${today}",
+		dataCollected: {
+			"Personal Information": ["Email address"],
 		},
-		email: {
-			group: "Personal Information",
-			label: "Email address"
+		legalBasis: "Legitimate interests",
+		retention: {
+			"All personal data": "As long as necessary for the purposes described in this policy",
 		},
-		ip_address: {
-			group: "Technical Data",
-			label: "IP address"
+		cookies: { essential: true, analytics: false, marketing: false },
+		thirdParties: [],
+		userRights: ["access", "erasure"],
+		jurisdictions: ["us"],
+	},` : ""}${policies.includes("terms") ? `
+	terms: {
+		effectiveDate: "${today}",
+		acceptance: { methods: ["using the service", "creating an account"] },
+		eligibility: { minimumAge: 13 },
+		accounts: {
+			registrationRequired: false,
+			userResponsibleForCredentials: true,
+			companyCanTerminate: true,
 		},
-		device_info: {
-			group: "Technical Data",
-			label: "Device type and browser"
+		prohibitedUses: [
+			"Violating any applicable laws or regulations",
+			"Infringing on intellectual property rights",
+			"Transmitting harmful or malicious content",
+		],
+		intellectualProperty: { companyOwnsService: true, usersMayNotCopy: true },
+		termination: { companyCanTerminate: true, userCanTerminate: true },
+		disclaimers: { serviceProvidedAsIs: true, noWarranties: true },
+		limitationOfLiability: { excludesIndirectDamages: true },
+		governingLaw: { jurisdiction: "Delaware, USA" },
+		changesPolicy: {
+			noticeMethod: "email or prominent notice on our website",
+			noticePeriodDays: 30,
 		},
-		location: {
-			group: "Location Data",
-			label: "Approximate location"
-		},
-		payment_info: {
-			group: "Financial Data",
-			label: "Payment card details"
-		},
-		usage_data: {
-			group: "Usage Data",
-			label: "Pages visited and features used"
-		}
-	};
+	},` : ""}${policies.includes("cookie") ? `
+	cookie: {
+		effectiveDate: "${today}",
+		cookies: { essential: true, analytics: false, functional: false, marketing: false },
+		jurisdictions: ["us"],
+	},` : ""}
+});
+`;
+}
+var initCommand;
+var init_init = __esmMin((() => {
 	initCommand = defineCommand({
 		meta: {
 			name: "init",
 			description: "Interactively create a policy config file"
 		},
-		args: {
-			out: {
-				type: "string",
-				description: "Output path for generated config",
-				default: ""
-			},
-			yes: {
-				type: "boolean",
-				description: "Skip prompts and use defaults (CI mode)",
-				default: false
-			},
-			type: {
-				type: "string",
-				description: "Policy type: \"privacy\" or \"terms\"",
-				default: "privacy"
-			}
-		},
+		args: { out: {
+			type: "string",
+			description: "Output path for generated config",
+			default: "openpolicy.ts"
+		} },
 		async run({ args }) {
-			const policyType = args.type === "terms" ? "terms" : "privacy";
-			const defaultOut = policyType === "terms" ? "./terms.config.ts" : "./privacy.config.ts";
-			consola.start(`OpenPolicy init wizard (${policyType})`);
-			const companyName = String(await consola.prompt("Company name?", {
-				type: "text",
-				cancel: "reject"
-			}));
-			const legalName = String(await consola.prompt("Legal entity name?", {
-				type: "text",
-				cancel: "reject",
-				initial: companyName
-			}));
-			const address = String(await consola.prompt("Company address?", {
+			consola.box("Welcome to OpenPolicy\nGenerate privacy policies, terms of service, and cookie policies from a single config file.");
+			consola.start("Let's get you set up.");
+			const source = getOpenPolicyTemplate(String(await consola.prompt("Company name?", {
 				type: "text",
 				cancel: "reject"
-			}));
-			const contact = String(await consola.prompt(policyType === "terms" ? "Legal contact email?" : "Privacy contact email?", {
+			})), String(await consola.prompt("Contact email?", {
 				type: "text",
 				cancel: "reject"
+			})), await consola.prompt("Which policies do you need?", {
+				type: "multiselect",
+				cancel: "reject",
+				options: [
+					"privacy",
+					"terms",
+					"cookie"
+				]
 			}));
-			let source;
-			if (policyType === "terms") source = renderTermsConfig({
-				companyName,
-				legalName,
-				address,
-				contact,
-				jurisdiction: String(await consola.prompt("Governing law jurisdiction? (e.g. Delaware, USA)", {
-					type: "text",
-					cancel: "reject",
-					initial: "Delaware, USA"
-				}))
-			});
-			else {
-				const jurisdictionChoice = String(await consola.prompt("Jurisdiction?", {
-					type: "select",
-					cancel: "reject",
-					options: [
-						"gdpr",
-						"ccpa",
-						"both"
-					]
-				}));
-				const dataCategories = await consola.prompt("Data categories collected?", {
-					type: "multiselect",
-					cancel: "reject",
-					options: [
-						"name",
-						"email",
-						"ip_address",
-						"device_info",
-						"location",
-						"payment_info",
-						"usage_data"
-					]
-				});
-				const hasCookies = Boolean(await consola.prompt("Does your app use cookies?", {
-					type: "confirm",
-					cancel: "reject",
-					initial: true
-				}));
-				const jurisdictions = toJurisdictions(jurisdictionChoice);
-				const dataCollected = toDataCollected(dataCategories);
-				const userRights = toUserRights(jurisdictions);
-				source = renderPrivacyConfig({
-					companyName,
-					legalName,
-					address,
-					contact,
-					jurisdictions,
-					dataCollected,
-					legalBasis: jurisdictions.includes("eu") ? "Legitimate interests and consent" : "",
-					hasCookies,
-					userRights
-				});
-			}
-			const outPath = resolve(args.out || defaultOut);
-			await Bun.write(outPath, source);
+			const outPath = resolve(args.out);
+			await writeFile(outPath, source);
 			consola.success(`Config written to ${outPath}`);
+			consola.info(`Open ${outPath} and fill in your company's details — address, legal name, and any policy-specific fields.`);
+			consola.info(`When you're ready, run:\n\n  openpolicy generate ${args.out}\n\nto compile your policies to HTML or Markdown.`);
 		}
 	});
 }));
 //#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";
-}
-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,9 +149,31 @@ var init_load_config = __esmMin((() => {}));
 //#endregion
 //#region src/commands/generate.ts
 var generate_exports = /* @__PURE__ */ __exportAll({ generateCommand: () => generateCommand });
+async function generateFromConfig(configPath, formats, outDir, bustCache = 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;
+		}
+		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;
+	}
+	throw new Error(`[openpolicy] Config must use defineConfig() (OpenPolicyConfig): ${configPath}`);
+}
 var generateCommand;
 var init_generate = __esmMin((() => {
-	init_detect_type();
 	init_load_config();
 	generateCommand = defineCommand({
 		meta: {
@@ -310,8 +183,8 @@ var init_generate = __esmMin((() => {
 		args: {
 			config: {
 				type: "positional",
-				description: "Path(s) to policy config file(s), comma-separated",
-				default: "./policy.config.ts,./terms.config.ts"
+				description: "Path to policy config file",
+				default: "./openpolicy.ts"
 			},
 			format: {
 				type: "string",
@@ -323,44 +196,33 @@ var init_generate = __esmMin((() => {
 				description: "Output directory",
 				default: "./output"
 			},
-			type: {
-				type: "string",
-				description: "Policy type: \"privacy\" or \"terms\" (auto-detected from filename if omitted)",
-				default: ""
+			watch: {
+				type: "boolean",
+				description: "Watch config file 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 configPath = args.config;
+			if (!existsSync(configPath)) throw new Error(`Config not found: ${configPath}`);
+			await generateFromConfig(configPath, formats, outDir);
 			consola.success(`Policy generation complete → ${outDir}`);
+			if (args.watch) {
+				consola.info("Watching for changes...");
+				let debounceTimer = null;
+				watch(configPath, () => {
+					if (debounceTimer) clearTimeout(debounceTimer);
+					debounceTimer = setTimeout(async () => {
+						try {
+							await generateFromConfig(configPath, formats, outDir, true);
+						} catch (err) {
+							consola.error(`Error regenerating ${configPath}:`, err);
+						}
+					}, 100);
+				});
+			}
 		}
 	});
 }));
@@ -369,7 +231,6 @@ var init_generate = __esmMin((() => {
 var validate_exports = /* @__PURE__ */ __exportAll({ validateCommand: () => validateCommand });
 var validateCommand;
 var init_validate = __esmMin((() => {
-	init_detect_type();
 	init_load_config();
 	validateCommand = defineCommand({
 		meta: {
@@ -386,31 +247,29 @@ var init_validate = __esmMin((() => {
 				type: "string",
 				description: "Jurisdiction to validate against: gdpr, ccpa, or all",
 				default: "all"
-			},
-			type: {
-				type: "string",
-				description: "Policy type: \"privacy\" or \"terms\" (auto-detected from filename if omitted)",
-				default: ""
 			}
 		},
 		async run({ args }) {
 			const configPath = args.config ?? "./policy.config.ts";
-			const policyType = detectType(args.type || void 0, configPath);
-			consola.start(`Validating ${policyType} policy: ${configPath}`);
 			const config = await loadConfig(configPath);
-			const issues = policyType === "terms" ? validateTermsOfService(config) : validatePrivacyPolicy(config);
-			if (issues.length === 0) {
-				consola.success("Config is valid — no issues found.");
-				return;
-			}
-			for (const issue of issues) if (issue.level === "error") consola.error(issue.message);
-			else consola.warn(issue.message);
-			const errors = issues.filter((i) => i.level === "error");
-			if (errors.length > 0) {
-				consola.fail(`Validation failed with ${errors.length} error(s).`);
-				process.exit(1);
+			if (!isOpenPolicyConfig(config)) throw new Error(`[openpolicy] Config must use defineConfig() (OpenPolicyConfig): ${configPath}`);
+			const inputs = expandOpenPolicyConfig(config);
+			let totalErrors = 0;
+			for (const input of inputs) {
+				consola.start(`Validating ${input.type} policy: ${configPath}`);
+				const issues = input.type === "terms" ? validateTermsOfService(input) : input.type === "cookie" ? validateCookiePolicy(input) : validatePrivacyPolicy(input);
+				if (issues.length === 0) {
+					consola.success(`${input.type}: no issues found.`);
+					continue;
+				}
+				for (const issue of issues) if (issue.level === "error") consola.error(issue.message);
+				else consola.warn(issue.message);
+				const errors = issues.filter((i) => i.level === "error");
+				totalErrors += errors.length;
+				if (errors.length > 0) consola.fail(`${input.type}: validation failed with ${errors.length} error(s).`);
+				else consola.success(`${input.type}: validation passed with warnings.`);
 			}
-			consola.success("Validation passed with warnings.");
+			if (totalErrors > 0) process.exit(1);
 		}
 	});
 }));
@@ -419,7 +278,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,9 +1,9 @@
 {
 	"name": "@openpolicy/cli",
-	"version": "0.0.10",
+	"version": "0.0.12",
 	"type": "module",
 	"description": "CLI for generating and validating OpenPolicy privacy policy documents",
-	"license": "MIT",
+	"license": "GPL-3.0-only",
 	"repository": {
 		"type": "git",
 		"url": "https://github.com/jamiedavenport/openpolicy",