@openpolicy/cli 0.0.9 → 0.0.11

package/README.md

@@ -1,3 +1,68 @@
-# OpenPolicy CLI
+# `@openpolicy/cli`
 
-This is the CLI package for the OpenPolicy project.
+> 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.
+
+## Install
+
+```sh
+bun add -D @openpolicy/cli
+bun add @openpolicy/sdk
+# or: npm install --save-dev @openpolicy/cli @openpolicy/sdk
+```
+
+Or run without installing:
+
+```sh
+bunx @openpolicy/cli --help
+```
+
+## Commands
+
+### `init` — interactive setup wizard
+
+Creates a starter config file with placeholder content:
+
+```sh
+openpolicy init                  # privacy policy (default)
+openpolicy init --type terms     # terms of service
+```
+
+### `generate` — compile a policy
+
+```sh
+openpolicy generate ./privacy.config.ts --format markdown,html --out ./public/policies
+openpolicy generate ./terms.config.ts   --format markdown      --out ./public/policies
+```
+
+| Flag | Default | Description |
+|---|---|---|
+| `--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.
+
+### `validate` — check a policy config
+
+```sh
+openpolicy validate ./privacy.config.ts
+openpolicy validate ./privacy.config.ts --jurisdiction gdpr
+```
+
+| Flag | Default | Description |
+|---|---|---|
+| `--jurisdiction` | `all` | Validate against: `gdpr`, `ccpa`, or `all` |
+| `--type` | auto-detected | Override policy type: `privacy` or `terms` |
+
+## Documentation
+
+[openpolicy.sh/docs/getting-started/cli](https://openpolicy.sh/docs/getting-started/cli)
+
+## Links
+
+- [GitHub](https://github.com/jamiedavenport/openpolicy)
+- [openpolicy.sh](https://openpolicy.sh)
+- [npm](https://www.npmjs.com/package/@openpolicy/cli)

package/dist/cli.js

@@ -2,8 +2,9 @@
 import { defineCommand, runMain } from "citty";
 import { join, resolve } from "node:path";
 import consola from "consola";
-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);
@@ -17,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) {
@@ -266,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);
@@ -297,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();
@@ -309,8 +365,8 @@ var init_generate = __esmMin((() => {
 		args: {
 			config: {
 				type: "positional",
-				description: "Path to policy config file",
-				default: "./policy.config.ts"
+				description: "Path(s) to policy config file(s), comma-separated",
+				default: "./openpolicy.ts,./policy.config.ts,./terms.config.ts"
 			},
 			format: {
 				type: "string",
@@ -324,31 +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 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}`);
-			}
+			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);
+					});
+				}
+			}
 		}
 	});
 }));
@@ -407,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.9",
+	"version": "0.0.11",
 	"type": "module",
 	"description": "CLI for generating and validating OpenPolicy privacy policy documents",
 	"license": "MIT",