@openpolicy/cli 0.0.4 → 0.0.6

package/src/commands/init.ts

@@ -1,197 +0,0 @@
-import { resolve } from "node:path";
-import type { Jurisdiction } from "@openpolicy/core";
-import { defineCommand } from "citty";
-import consola from "consola";
-
-const DATA_CATEGORY_MAP: Record<string, { group: string; label: string }> = {
-	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" },
-};
-
-function toJurisdictions(choice: string): Jurisdiction[] {
-	if (choice === "gdpr") return ["eu"];
-	if (choice === "ccpa") return ["ca"];
-	if (choice === "both") return ["eu", "ca"];
-	return ["us"];
-}
-
-function toDataCollected(categories: string[]): Record<string, string[]> {
-	const groups: Record<string, string[]> = {};
-	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: Jurisdiction[]): string[] {
-	const rights = new Set<string>(["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 renderConfig(values: {
-	companyName: string;
-	legalName: string;
-	address: string;
-	contact: string;
-	jurisdictions: Jurisdiction[];
-	dataCollected: Record<string, string[]>;
-	legalBasis: string;
-	hasCookies: boolean;
-	userRights: string[];
-}): string {
-	const dataLines = Object.entries(values.dataCollected)
-		.map(([k, v]) => `    ${JSON.stringify(k)}: ${JSON.stringify(v)},`)
-		.join("\n");
-
-	const today = new Date().toISOString().slice(0, 10);
-
-	return `import { definePrivacyPolicy } from "@openpolicy/sdk";
-
-export default definePrivacyPolicy({
-  effectiveDate: "${today}",
-  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)},
-});
-`;
-}
-
-export const initCommand = defineCommand({
-	meta: {
-		name: "init",
-		description: "Interactively create a policy config file",
-	},
-	args: {
-		out: {
-			type: "string",
-			description: "Output path for generated config",
-			default: "./policy.config.ts",
-		},
-		yes: {
-			type: "boolean",
-			description: "Skip prompts and use defaults (CI mode)",
-			default: false,
-		},
-	},
-	async run({ args }) {
-		consola.start("OpenPolicy init wizard");
-
-		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("Privacy contact email?", {
-				type: "text",
-				cancel: "reject",
-			}),
-		);
-
-		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",
-			],
-		})) as string[];
-
-		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);
-		const legalBasis = jurisdictions.includes("eu")
-			? "Legitimate interests and consent"
-			: "";
-
-		const source = renderConfig({
-			companyName,
-			legalName,
-			address,
-			contact,
-			jurisdictions,
-			dataCollected,
-			legalBasis,
-			hasCookies,
-			userRights,
-		});
-
-		const outPath = resolve(args.out ?? "./policy.config.ts");
-		await Bun.write(outPath, source);
-		consola.success(`Config written to ${outPath}`);
-	},
-});

package/src/commands/validate.test.ts

@@ -1,15 +0,0 @@
-import { expect, test } from "bun:test";
-import type { ArgsDef, CommandMeta } from "citty";
-import { validateCommand } from "./validate";
-
-test("validateCommand has correct name", () => {
-	expect((validateCommand.meta as CommandMeta)?.name).toBe("validate");
-});
-
-test("validateCommand has config positional arg", () => {
-	expect((validateCommand.args as ArgsDef)?.config?.type).toBe("positional");
-});
-
-test("validateCommand has jurisdiction arg", () => {
-	expect((validateCommand.args as ArgsDef)?.jurisdiction?.type).toBe("string");
-});

package/src/commands/validate.ts

@@ -1,53 +0,0 @@
-import type { PrivacyPolicyConfig } from "@openpolicy/core";
-import { validatePrivacyPolicy } from "@openpolicy/core";
-import { defineCommand } from "citty";
-import consola from "consola";
-import { loadConfig } from "../utils/load-config";
-
-export 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",
-		},
-	},
-	async run({ args }) {
-		const configPath = args.config ?? "./policy.config.ts";
-
-		consola.start(`Validating ${configPath}`);
-
-		const config = await loadConfig(configPath);
-		const issues = validatePrivacyPolicy(config as PrivacyPolicyConfig);
-
-		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.");
-	},
-});

package/src/index.test.ts

@@ -1,29 +0,0 @@
-import { expect, test } from "bun:test";
-import type { CommandMeta, SubCommandsDef } from "citty";
-import { mainCommand, run } from "./index";
-
-test("run is a function", () => {
-	expect(typeof run).toBe("function");
-});
-
-test("mainCommand has correct name", () => {
-	expect((mainCommand.meta as CommandMeta)?.name).toBe("openpolicy");
-});
-
-test("mainCommand has init subcommand", () => {
-	expect(typeof (mainCommand.subCommands as SubCommandsDef)?.init).toBe(
-		"function",
-	);
-});
-
-test("mainCommand has generate subcommand", () => {
-	expect(typeof (mainCommand.subCommands as SubCommandsDef)?.generate).toBe(
-		"function",
-	);
-});
-
-test("mainCommand has validate subcommand", () => {
-	expect(typeof (mainCommand.subCommands as SubCommandsDef)?.validate).toBe(
-		"function",
-	);
-});

package/src/index.ts

@@ -1,21 +0,0 @@
-import { defineCommand } from "citty";
-
-export const mainCommand = defineCommand({
-	meta: {
-		name: "openpolicy",
-		version: "0.0.1",
-		description: "Generate and validate privacy policy documents",
-	},
-	subCommands: {
-		init: () => import("./commands/init").then((m) => m.initCommand),
-		generate: () =>
-			import("./commands/generate").then((m) => m.generateCommand),
-		validate: () =>
-			import("./commands/validate").then((m) => m.validateCommand),
-	},
-});
-
-export async function run() {
-	const { runMain } = await import("citty");
-	await runMain(mainCommand);
-}

package/src/utils/load-config.ts

@@ -1,32 +0,0 @@
-import { resolve } from "node:path";
-import consola from "consola";
-
-export async function loadConfig(configPath: string): Promise<unknown> {
-	const absPath = resolve(configPath);
-
-	if (!(await Bun.file(absPath).exists())) {
-		consola.error(`Config file not found: ${absPath}`);
-		process.exit(1);
-	}
-
-	let mod: unknown;
-	try {
-		mod = await import(absPath);
-	} catch (err) {
-		consola.error(`Failed to load config: ${absPath}`);
-		consola.error(err);
-		process.exit(1);
-	}
-
-	const config =
-		(mod as Record<string, unknown>)["default"] ??
-		(mod as Record<string, unknown>)["module.exports"] ??
-		mod;
-
-	if (config === null || config === undefined || typeof config !== "object") {
-		consola.error(`Config must export a non-null object: ${absPath}`);
-		process.exit(1);
-	}
-
-	return config;
-}