@openpolicy/cli 0.0.11 → 0.0.13

package/README.md

@@ -2,7 +2,7 @@
 
 > CLI for generating and validating [OpenPolicy](https://openpolicy.sh) policy documents.
 
-Compile privacy policies and terms of service to Markdown or HTML from the command line — no Vite or Astro required.
+Compile privacy policies and terms of service to Markdown, HTML, or PDF from the command line — no Vite or Astro required.
 
 ## Install
 
@@ -38,7 +38,7 @@ openpolicy generate ./terms.config.ts   --format markdown      --out ./public/po
 
 | Flag | Default | Description |
 |---|---|---|
-| `--format` | `markdown` | Comma-separated output formats: `markdown`, `html` |
+| `--format` | `markdown` | Comma-separated output formats: `markdown`, `html`, `pdf` |
 | `--out` | `./public/policies` | Output directory |
 | `--type` | auto-detected | Override policy type: `privacy` or `terms` |
 | `--watch` | `false` | Watch config files and regenerate on changes |

package/dist/cli.js

@@ -1,487 +1 @@
-#!/usr/bin/env node
-import { defineCommand, runMain } from "citty";
-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";
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	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) {
-	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)},
-});
-`;
-}
-function renderTermsConfig(values) {
-	return `import { defineTermsOfService } 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"
-		},
-		ip_address: {
-			group: "Technical Data",
-			label: "IP address"
-		},
-		device_info: {
-			group: "Technical Data",
-			label: "Device type and browser"
-		},
-		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"
-		}
-	};
-	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"
-			}
-		},
-		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?", {
-				type: "text",
-				cancel: "reject"
-			}));
-			const contact = String(await consola.prompt(policyType === "terms" ? "Legal contact email?" : "Privacy contact email?", {
-				type: "text",
-				cancel: "reject"
-			}));
-			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);
-			consola.success(`Config written to ${outPath}`);
-		}
-	});
-}));
-//#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);
-	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(importPath);
-	} catch (err) {
-		consola.error(`Failed to load config: ${absPath}`);
-		consola.error(err);
-		process.exit(1);
-	}
-	const config = mod["default"] ?? mod["module.exports"] ?? mod;
-	if (config === null || config === void 0 || typeof config !== "object") {
-		consola.error(`Config must export a non-null object: ${absPath}`);
-		process.exit(1);
-	}
-	return config;
-}
-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();
-	init_load_config();
-	generateCommand = defineCommand({
-		meta: {
-			name: "generate",
-			description: "Compile a policy config to one or more output formats"
-		},
-		args: {
-			config: {
-				type: "positional",
-				description: "Path(s) to policy config file(s), comma-separated",
-				default: "./openpolicy.ts,./policy.config.ts,./terms.config.ts"
-			},
-			format: {
-				type: "string",
-				description: "Comma-separated output formats: markdown,pdf,jsx",
-				default: "markdown"
-			},
-			out: {
-				type: "string",
-				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",
-				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}`);
-			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);
-					});
-				}
-			}
-		}
-	});
-}));
-//#endregion
-//#region src/commands/validate.ts
-var validate_exports = /* @__PURE__ */ __exportAll({ validateCommand: () => validateCommand });
-var validateCommand;
-var init_validate = __esmMin((() => {
-	init_detect_type();
-	init_load_config();
-	validateCommand = defineCommand({
-		meta: {
-			name: "validate",
-			description: "Validate a policy config for compliance"
-		},
-		args: {
-			config: {
-				type: "positional",
-				description: "Path to policy config file",
-				default: "./policy.config.ts"
-			},
-			jurisdiction: {
-				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);
-			}
-			consola.success("Validation passed with warnings.");
-		}
-	});
-}));
-//#endregion
-//#region src/cli.ts
-runMain(defineCommand({
-	meta: {
-		name: "openpolicy",
-		version,
-		description: "Generate and validate privacy policy documents"
-	},
-	subCommands: {
-		init: () => Promise.resolve().then(() => (init_init(), init_exports)).then((m) => m.initCommand),
-		generate: () => Promise.resolve().then(() => (init_generate(), generate_exports)).then((m) => m.generateCommand),
-		validate: () => Promise.resolve().then(() => (init_validate(), validate_exports)).then((m) => m.validateCommand)
-	}
-}));
-//#endregion
-export {};
+#!/usr/bin/env bun

package/package.json

@@ -1,9 +1,9 @@
 {
 	"name": "@openpolicy/cli",
-	"version": "0.0.11",
+	"version": "0.0.13",
 	"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",
@@ -14,7 +14,12 @@
 		"README.md"
 	],
 	"bin": {
-		"openpolicy": "./dist/cli.js"
+		"openpolicy": "./src/cli.ts"
+	},
+	"publishConfig": {
+		"bin": {
+			"openpolicy": "./dist/cli.js"
+		}
 	},
 	"scripts": {
 		"dev": "rolldown -c --watch",
@@ -28,6 +33,7 @@
 	},
 	"devDependencies": {
 		"@openpolicy/core": "workspace:*",
+		"@openpolicy/renderers": "workspace:*",
 		"@openpolicy/tooling": "workspace:*"
 	}
 }

package/src/cli.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env bun
+import { runMain } from "citty";
+import { mainCommand } from "./index";
+
+runMain(mainCommand);

package/dist/_cli-BVVbyDQ9.js

@@ -1,49 +0,0 @@
-import { n as detectType, t as loadConfig } from "./_cli-BjVuFgXe.js";
-import { defineCommand } from "citty";
-import { validatePrivacyPolicy, validateTermsOfService } from "@openpolicy/core";
-import consola from "consola";
-//#region src/commands/validate.ts
-const validateCommand = defineCommand({
-	meta: {
-		name: "validate",
-		description: "Validate a policy config for compliance"
-	},
-	args: {
-		config: {
-			type: "positional",
-			description: "Path to policy config file",
-			default: "./policy.config.ts"
-		},
-		jurisdiction: {
-			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);
-		}
-		consola.success("Validation passed with warnings.");
-	}
-});
-//#endregion
-export { validateCommand };

package/dist/_cli-BjVuFgXe.js

@@ -1,33 +0,0 @@
-import { resolve } from "node:path";
-import consola from "consola";
-import { existsSync } from "node:fs";
-//#region src/utils/detect-type.ts
-function detectType(explicitType, configPath) {
-	if (explicitType === "privacy" || explicitType === "terms") return explicitType;
-	return configPath.toLowerCase().includes("terms") ? "terms" : "privacy";
-}
-//#endregion
-//#region src/utils/load-config.ts
-async function loadConfig(configPath) {
-	const absPath = resolve(configPath);
-	if (!existsSync(absPath)) {
-		consola.error(`Config file not found: ${absPath}`);
-		process.exit(1);
-	}
-	let mod;
-	try {
-		mod = await import(absPath);
-	} catch (err) {
-		consola.error(`Failed to load config: ${absPath}`);
-		consola.error(err);
-		process.exit(1);
-	}
-	const config = mod["default"] ?? mod["module.exports"] ?? mod;
-	if (config === null || config === void 0 || typeof config !== "object") {
-		consola.error(`Config must export a non-null object: ${absPath}`);
-		process.exit(1);
-	}
-	return config;
-}
-//#endregion
-export { detectType as n, loadConfig as t };

package/dist/_cli-C-Vx-Nop.js

@@ -1,58 +0,0 @@
-import { n as detectType, t as loadConfig } from "./_cli-BjVuFgXe.js";
-import { defineCommand } from "citty";
-import { join } from "node:path";
-import { compilePolicy } from "@openpolicy/core";
-import consola from "consola";
-//#region src/commands/generate.ts
-const generateCommand = defineCommand({
-	meta: {
-		name: "generate",
-		description: "Compile a policy config to one or more output formats"
-	},
-	args: {
-		config: {
-			type: "positional",
-			description: "Path to policy config file",
-			default: "./policy.config.ts"
-		},
-		format: {
-			type: "string",
-			description: "Comma-separated output formats: markdown,pdf,jsx",
-			default: "markdown"
-		},
-		out: {
-			type: "string",
-			description: "Output directory",
-			default: "./output"
-		},
-		type: {
-			type: "string",
-			description: "Policy type: \"privacy\" or \"terms\" (auto-detected from filename if omitted)",
-			default: ""
-		}
-	},
-	async run({ args }) {
-		const formats = (args.format ?? "markdown").split(",").map((f) => f.trim()).filter(Boolean);
-		const outDir = args.out ?? "./output";
-		const configPath = args.config ?? "./policy.config.ts";
-		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 });
-		for (const result of results) {
-			const outPath = join(outDir, `${outputFilename}.${result.format === "markdown" ? "md" : result.format}`);
-			await Bun.write(outPath, result.content);
-			consola.success(`Written: ${outPath}`);
-		}
-		consola.success(`Policy generation complete → ${outDir}`);
-	}
-});
-//#endregion
-export { generateCommand };