@openpolicy/cli 0.0.11 → 0.0.12

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 { existsSync, watch } from "node:fs";
-import { mkdir, writeFile } from "node:fs/promises";
-import { compilePolicy, expandOpenPolicyConfig, isOpenPolicyConfig, validatePrivacyPolicy, validateTermsOfService } from "@openpolicy/core";
+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);
@@ -19,265 +19,109 @@ var __exportAll = (all, no_symbols) => {
 };
 //#endregion
 //#region package.json
-var version = "0.0.11";
+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"
-		},
-		email: {
-			group: "Personal Information",
-			label: "Email address"
+export default defineConfig({
+	company: {
+		name: "${companyName}",
+		legalName: "${companyName}",
+		address: "",
+		contact: "${contactEmail}",
+	},${policies.includes("privacy") ? `
+	privacy: {
+		effectiveDate: "${today}",
+		dataCollected: {
+			"Personal Information": ["Email address"],
 		},
-		ip_address: {
-			group: "Technical Data",
-			label: "IP address"
+		legalBasis: "Legitimate interests",
+		retention: {
+			"All personal data": "As long as necessary for the purposes described in this policy",
 		},
-		device_info: {
-			group: "Technical Data",
-			label: "Device type and browser"
+		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,
 		},
-		location: {
-			group: "Location Data",
-			label: "Approximate location"
+		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,
 		},
-		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" || 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, bustCache = false) {
 	const absPath = resolve(configPath);
@@ -305,28 +149,13 @@ 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;
+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 true;
+			return;
 		}
 		await mkdir(outDir, { recursive: true });
 		for (const input of inputs) {
@@ -339,23 +168,12 @@ async function generateFromConfig(configPath, formats, outDir, explicitType, bus
 				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;
 	}
-	return true;
+	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: {
@@ -365,8 +183,8 @@ var init_generate = __esmMin((() => {
 		args: {
 			config: {
 				type: "positional",
-				description: "Path(s) to policy config file(s), comma-separated",
-				default: "./openpolicy.ts,./policy.config.ts,./terms.config.ts"
+				description: "Path to policy config file",
+				default: "./openpolicy.ts"
 			},
 			format: {
 				type: "string",
@@ -378,43 +196,32 @@ var init_generate = __esmMin((() => {
 				description: "Output directory",
 				default: "./output"
 			},
-			type: {
-				type: "string",
-				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",
+				description: "Watch config file and regenerate on changes",
 				default: false
 			}
 		},
 		async run({ args }) {
 			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}`);
+			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 && watchablePaths.length > 0) {
+			if (args.watch) {
 				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);
-					});
-				}
+				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);
+				});
 			}
 		}
 	});
@@ -424,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: {
@@ -441,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);
 		}
 	});
 }));

package/package.json

@@ -1,9 +1,9 @@
 {
 	"name": "@openpolicy/cli",
-	"version": "0.0.11",
+	"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",