@openpolicy/cli 0.0.12 → 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,291 +1 @@
-#!/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 { 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);
-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.12";
-//#endregion
-//#region src/commands/init.ts
-var init_exports = /* @__PURE__ */ __exportAll({
-	getOpenPolicyTemplate: () => getOpenPolicyTemplate,
-	initCommand: () => initCommand
-});
-function getOpenPolicyTemplate(companyName, contactEmail, policies) {
-	const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-	return `import { defineConfig } from "@openpolicy/sdk";
-
-export default defineConfig({
-	company: {
-		name: "${companyName}",
-		legalName: "${companyName}",
-		address: "",
-		contact: "${contactEmail}",
-	},${policies.includes("privacy") ? `
-	privacy: {
-		effectiveDate: "${today}",
-		dataCollected: {
-			"Personal Information": ["Email address"],
-		},
-		legalBasis: "Legitimate interests",
-		retention: {
-			"All personal data": "As long as necessary for the purposes described in this policy",
-		},
-		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,
-		},
-		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,
-		},
-	},` : ""}${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: "openpolicy.ts"
-		} },
-		async run({ args }) {
-			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"
-			})), 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"
-				]
-			}));
-			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/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 });
-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_load_config();
-	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: "./openpolicy.ts"
-			},
-			format: {
-				type: "string",
-				description: "Comma-separated output formats: markdown,pdf,jsx",
-				default: "markdown"
-			},
-			out: {
-				type: "string",
-				description: "Output directory",
-				default: "./output"
-			},
-			watch: {
-				type: "boolean",
-				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 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);
-				});
-			}
-		}
-	});
-}));
-//#endregion
-//#region src/commands/validate.ts
-var validate_exports = /* @__PURE__ */ __exportAll({ validateCommand: () => validateCommand });
-var validateCommand;
-var init_validate = __esmMin((() => {
-	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"
-			}
-		},
-		async run({ args }) {
-			const configPath = args.config ?? "./policy.config.ts";
-			const config = await loadConfig(configPath);
-			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.`);
-			}
-			if (totalErrors > 0) process.exit(1);
-		}
-	});
-}));
-//#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,6 +1,6 @@
 {
 	"name": "@openpolicy/cli",
-	"version": "0.0.12",
+	"version": "0.0.13",
 	"type": "module",
 	"description": "CLI for generating and validating OpenPolicy privacy policy documents",
 	"license": "GPL-3.0-only",
@@ -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 };