privon 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tosmim
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,171 @@
+# Privon
+
+Privon is a dependency-free Node.js SDK and CLI that drafts a privacy policy and terms of use from a project's documentation, then creates pages appropriate for the detected frontend stack.
+
+> Generated legal text is a draft, not legal advice. Before publishing, review it for your real data practices and add the operator's legal name, address, contact email, and any product-specific disclosures.
+
+## What it supports
+
+| Project | Output | Integration |
+| --- | --- | --- |
+| Next.js App Router | `app/privacy-policy/page.*` and `app/terms-of-use/page.*` (also supports `src/app`) | File-system routing |
+| Next.js Pages Router | `pages/privacy-policy.*` and `pages/terms-of-use.*` (also supports `src/pages`) | File-system routing |
+| React + React Router | Two components under `src/pages` | Adds routes to a conventional `src/App.*`, `routes.*`, or `router.*` containing `<Routes>` |
+| React without React Router | Two components under `src/pages` | Components only, with a warning |
+| Angular | Two standalone components under `src/app` | Adds routes to `app.routes.ts` or `app-routing.module.ts` when conventional routing is found |
+| HTML, backend, or generic project | `privacy-policy.html` and `terms-of-use.html` | Standalone HTML |
+
+Pages use inline styling. Privon looks for colors in conventional home, header, footer, layout, global, and theme files and otherwise uses a neutral default palette.
+
+## Requirements
+
+- Node.js 18 or newer
+- An AI endpoint compatible with OpenAI chat completions, Anthropic Messages, or Google Gemini generateContent
+
+Set these variables in the shell or a `.env` file in the target project. Existing process environment values take precedence over `.env` values.
+
+```dotenv
+PRI_AI_URL=https://api.openai.com/v1
+PRI_AI_MODEL=gpt-4.1-mini
+PRI_AI_API_KEY=your-key
+```
+
+Anthropic example:
+
+```dotenv
+PRI_AI_URL=https://api.anthropic.com
+PRI_AI_MODEL=claude-sonnet-4-5
+PRI_AI_API_KEY=your-key
+```
+
+Gemini example:
+
+```dotenv
+PRI_AI_URL=https://generativelanguage.googleapis.com
+PRI_AI_MODEL=gemini-2.5-flash
+PRI_AI_API_KEY=your-key
+```
+
+The URL can be either the provider base URL or the complete generation endpoint. Provider selection is automatic from the URL and can be overridden with `--provider` or the SDK's `provider` option.
+
+## CLI
+
+Run against the current project:
+
+```bash
+npx privon --country India
+```
+
+Run against another directory and include source code in the AI context:
+
+```bash
+npx privon ../my-app --country "United Kingdom" --full-scan
+```
+
+Use deterministic mock content while developing—no credentials or network request is required:
+
+```bash
+npx privon ./example --mock
+```
+
+Preview detection and planned writes:
+
+```bash
+npx privon --mock --dry-run --json
+```
+
+Existing policy pages are never overwritten unless `--force` is supplied.
+
+```text
+Usage: privon [path] [options]
+
+  -c, --country <country>   Target country (default: India)
+      --full-scan           Include source files in AI context
+      --mock                Use deterministic mock AI content
+      --force               Overwrite existing generated pages
+      --dry-run             Detect and generate without writing files
+      --provider <name>     auto, openai, anthropic, or gemini
+      --date <YYYY-MM-DD>   Override the effective date
+      --json                Print a machine-readable result
+```
+
+`PRI_AI_MOCK=1` is equivalent to `--mock`.
+
+## SDK
+
+```js
+import { generateLegalPages } from 'privon';
+
+const result = await generateLegalPages({
+  root: process.cwd(),
+  country: 'India',
+  fullScan: false
+});
+
+console.log(result.project);
+console.log(result.output.files);
+```
+
+Development/mock usage:
+
+```js
+const result = await generateLegalPages({
+  root: './fixtures/react-app',
+  country: 'India',
+  mock: true,
+  dryRun: false
+});
+```
+
+Custom credentials and transport can be passed without changing global environment variables:
+
+```js
+await generateLegalPages({
+  aiUrl: 'https://provider.example/v1',
+  aiModel: 'model-name',
+  aiApiKey: process.env.MY_PROVIDER_KEY,
+  provider: 'openai',
+  headers: { 'X-Organization': 'example' },
+  fetch: customFetch
+});
+```
+
+Important options:
+
+- `root`: target project; defaults to `process.cwd()`.
+- `country`: drafting jurisdiction; defaults to `India`.
+- `fullScan`: scans bounded text/source files instead of product Markdown only.
+- `force`: overwrites existing generated pages. Off by default.
+- `dryRun`: returns detection, content, and intended writes without changing files.
+- `mock`: uses a deterministic local response.
+- `maxFiles`, `maxBytes`, `maxFileBytes`: cap AI context size.
+- `client`: provide an object with an async `generate(prompt)` method for a completely custom provider.
+- `loadEnv`: set to `false` to disable reading the target project's `.env`.
+
+The resolved result includes framework detection, scanned filenames, selected theme, normalized policy content, created/skipped files, route integrations, and warnings.
+
+## Scanning and privacy
+
+By default Privon reads common product Markdown such as `README.md`, `PRD.md`, `REQUIREMENTS.md`, `PLAN.md`, architecture/specification files, and Markdown under `docs/`. It does not scan the complete codebase unless `fullScan`/`--full-scan` is enabled.
+
+Even in full-scan mode, generated/build/vendor directories, hidden directories, binary files, and oversized inputs are excluded. The scanned text is sent to the configured AI provider, so review your provider's data terms before using full scan on sensitive repositories.
+
+## Safe generation behavior
+
+- Generated paths are constrained to the target project.
+- Existing legal pages are preserved unless force mode is explicit.
+- AI output is normalized into a strict document schema; the provider cannot choose arbitrary filesystem paths.
+- Router files are changed only when a conventional, recognizable route container is found. Otherwise Privon creates the pages and reports a manual integration warning.
+- The project is never executed by Privon.
+
+## Publishing
+
+The included GitHub Actions workflow publishes when a GitHub Release is published or when manually dispatched. Before using it:
+
+1. Update the `repository.url` in `package.json`.
+2. Add an npm automation token as the `NPM_TOKEN` repository secret (unless your npm trusted-publishing setup removes that requirement).
+3. Commit the lockfile, run `npm test`, create a release, and let the workflow publish with npm provenance.
+
+## License
+
+MIT

package/bin/privon.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+import { readFile } from 'node:fs/promises';
+import { generateLegalPages } from '../src/index.js';
+
+const HELP = `privon - generate privacy and terms pages
+
+Usage:
+  privon [path] [options]
+
+Options:
+  -c, --country <country>   Target country (default: India)
+      --full-scan           Include source files in AI context
+      --mock                Use deterministic mock AI content
+      --force               Overwrite existing generated pages
+      --dry-run             Detect and generate without writing files
+      --provider <name>     auto, openai, anthropic, or gemini
+      --date <YYYY-MM-DD>   Effective date (default: today)
+      --json                Print the result as JSON
+  -h, --help                Show this help
+  -v, --version             Show package version
+
+Environment:
+  PRI_AI_URL, PRI_AI_MODEL, PRI_AI_API_KEY
+  PRI_AI_MOCK=1 can be used instead of --mock during development.
+`;
+
+function takeValue(args, index, flag) {
+  const value = args[index + 1];
+  if (!value || value.startsWith('-')) throw new Error(`${flag} requires a value.`);
+  return value;
+}
+
+function parseArgs(args) {
+  const options = {};
+  let root;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === '-h' || arg === '--help') options.help = true;
+    else if (arg === '-v' || arg === '--version') options.version = true;
+    else if (arg === '--mock') options.mock = true;
+    else if (arg === '--full-scan') options.fullScan = true;
+    else if (arg === '--force') options.force = true;
+    else if (arg === '--dry-run') options.dryRun = true;
+    else if (arg === '--json') options.json = true;
+    else if (arg === '-c' || arg === '--country') { options.country = takeValue(args, index, arg); index += 1; }
+    else if (arg === '--provider') { options.provider = takeValue(args, index, arg); index += 1; }
+    else if (arg === '--date') { options.date = takeValue(args, index, arg); index += 1; }
+    else if (arg.startsWith('-')) throw new Error(`Unknown option: ${arg}`);
+    else if (!root) root = arg;
+    else throw new Error(`Unexpected argument: ${arg}`);
+  }
+  options.root = root;
+  return options;
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  if (options.help) { console.log(HELP); return; }
+  if (options.version) {
+    const pkg = JSON.parse(await readFile(new URL('../package.json', import.meta.url), 'utf8'));
+    console.log(pkg.version);
+    return;
+  }
+  const result = await generateLegalPages(options);
+  if (options.json) { console.log(JSON.stringify(result, null, 2)); return; }
+  const detected = `${result.project.framework}${result.project.router !== 'none' ? ` / ${result.project.router}` : ''}`;
+  console.log(`Privon generated legal pages for ${result.content.projectName}.`);
+  console.log(`Detected: ${detected} | Country: ${result.country} | AI: ${result.mock ? 'mock' : 'configured provider'}`);
+  for (const file of result.output.files) console.log(`  created  ${file}`);
+  for (const file of result.output.integrations) console.log(`  updated  ${file}`);
+  for (const file of result.output.skipped) console.log(`  skipped  ${file} (already exists; use --force)`);
+  for (const warning of result.output.warnings) console.warn(`  warning  ${warning}`);
+  if (options.dryRun) console.log('Dry run: no files were written.');
+}
+
+main().catch((error) => {
+  console.error(`privon: ${error.message}`);
+  if (process.env.DEBUG) console.error(error.stack);
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "privon",
+  "version": "0.1.0",
+  "description": "Generate privacy policy and terms of use pages for web projects with AI.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TosmimForidMehtab/Privon.git"
+  },
+  "type": "module",
+  "main": "./src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./ai": "./src/ai/client.js"
+  },
+  "bin": {
+    "privon": "./bin/privon.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test",
+    "check": "node --check bin/privon.js && node --check src/index.js",
+    "prepublishOnly": "npm test"
+  },
+  "keywords": [
+    "privacy-policy",
+    "terms-of-use",
+    "legal",
+    "ai",
+    "sdk",
+    "nextjs",
+    "react",
+    "angular"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/ai/client.js

@@ -0,0 +1,130 @@
+import { AIResponseError, ConfigurationError } from '../errors.js';
+
+function providerFromUrl(url, explicit = 'auto') {
+  if (explicit && explicit !== 'auto') return explicit;
+  if (/anthropic\.com/i.test(url)) return 'anthropic';
+  if (/generativelanguage\.googleapis\.com/i.test(url)) return 'gemini';
+  return 'openai';
+}
+
+function endpointFor(url, provider, model, key) {
+  const trimmed = url.replace(/\/$/, '');
+  if (provider === 'anthropic' && !/\/messages(?:\?|$)/.test(trimmed)) {
+    return /\/v1$/.test(trimmed) ? `${trimmed}/messages` : `${trimmed}/v1/messages`;
+  }
+  if (provider === 'gemini') {
+    const base = /:generateContent(?:\?|$)/.test(trimmed)
+      ? trimmed
+      : /\/v1(?:beta)?$/.test(trimmed)
+        ? `${trimmed}/models/${encodeURIComponent(model)}:generateContent`
+        : `${trimmed}/v1beta/models/${encodeURIComponent(model)}:generateContent`;
+    const join = base.includes('?') ? '&' : '?';
+    return `${base}${join}key=${encodeURIComponent(key)}`;
+  }
+  if (!/(?:chat\/completions|responses|completions)(?:\?|$)/.test(trimmed)) return `${trimmed}/chat/completions`;
+  return trimmed;
+}
+
+function requestFor(provider, model, prompt, maxTokens, endpoint) {
+  if (provider === 'anthropic') {
+    return { model, max_tokens: maxTokens, messages: [{ role: 'user', content: prompt }] };
+  }
+  if (provider === 'gemini') {
+    return { contents: [{ role: 'user', parts: [{ text: prompt }] }], generationConfig: { maxOutputTokens: maxTokens, responseMimeType: 'application/json' } };
+  }
+  if (/\/responses(?:\?|$)/.test(endpoint)) {
+    return { model, input: prompt, max_output_tokens: maxTokens };
+  }
+  if (/\/completions(?:\?|$)/.test(endpoint) && !/\/chat\/completions(?:\?|$)/.test(endpoint)) {
+    return { model, prompt, temperature: 0.2, max_tokens: maxTokens };
+  }
+  return { model, messages: [{ role: 'user', content: prompt }], temperature: 0.2, max_tokens: maxTokens };
+}
+
+function contentToText(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) return content.map((part) =>
+    typeof part === 'string' ? part : part?.text ?? part?.content ?? part?.value ?? ''
+  ).join('');
+  if (content && typeof content === 'object') return content.text ?? content.value ?? '';
+  return '';
+}
+
+export function extractResponseText(payload) {
+  if (typeof payload === 'string') return payload;
+  if (!payload || typeof payload !== 'object') return '';
+  if (typeof payload.output_text === 'string') return payload.output_text;
+  const choice = payload.choices?.[0];
+  if (choice) return contentToText(choice.message?.content ?? choice.text);
+  if (Array.isArray(payload.content)) return contentToText(payload.content);
+  const candidateParts = payload.candidates?.[0]?.content?.parts;
+  if (candidateParts) return contentToText(candidateParts);
+  if (Array.isArray(payload.output)) {
+    return payload.output.flatMap((item) => item.content || item).map(contentToText).join('');
+  }
+  if (payload.data) return extractResponseText(payload.data);
+  return '';
+}
+
+export function parseJsonResponse(text) {
+  const clean = String(text).trim().replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '');
+  try { return JSON.parse(clean); } catch (firstError) {
+    const start = clean.indexOf('{');
+    const end = clean.lastIndexOf('}');
+    if (start >= 0 && end > start) {
+      try { return JSON.parse(clean.slice(start, end + 1)); } catch { /* report original below */ }
+    }
+    throw new AIResponseError('The AI provider returned text that was not valid JSON.', firstError);
+  }
+}
+
+export class AIClient {
+  constructor(options = {}) {
+    this.url = options.url ?? process.env.PRI_AI_URL;
+    this.model = options.model ?? process.env.PRI_AI_MODEL;
+    this.apiKey = options.apiKey ?? process.env.PRI_AI_API_KEY;
+    this.provider = providerFromUrl(this.url || '', options.provider);
+    this.fetch = options.fetch ?? globalThis.fetch;
+    this.timeout = options.timeout ?? 120_000;
+    this.maxTokens = options.maxTokens ?? 8_000;
+    this.headers = options.headers ?? {};
+  }
+
+  validate() {
+    const missing = [!this.url && 'PRI_AI_URL', !this.model && 'PRI_AI_MODEL', !this.apiKey && 'PRI_AI_API_KEY'].filter(Boolean);
+    if (missing.length) throw new ConfigurationError(`Missing required AI configuration: ${missing.join(', ')}. Set the environment variables or use mock: true.`);
+    if (typeof this.fetch !== 'function') throw new ConfigurationError('No Fetch implementation is available. Privon requires Node.js 18 or newer.');
+  }
+
+  async generate(prompt) {
+    this.validate();
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeout);
+    const headers = { 'content-type': 'application/json', ...this.headers };
+    if (this.provider === 'anthropic') {
+      headers['x-api-key'] ??= this.apiKey;
+      headers['anthropic-version'] ??= '2023-06-01';
+    } else if (this.provider !== 'gemini') {
+      headers.authorization ??= `Bearer ${this.apiKey}`;
+    }
+    let response;
+    const endpoint = endpointFor(this.url, this.provider, this.model, this.apiKey);
+    try {
+      response = await this.fetch(endpoint, {
+        method: 'POST', headers, body: JSON.stringify(requestFor(this.provider, this.model, prompt, this.maxTokens, endpoint)), signal: controller.signal
+      });
+    } catch (error) {
+      const message = error?.name === 'AbortError' ? `AI request timed out after ${this.timeout}ms.` : `Could not reach the AI provider: ${error.message}`;
+      throw new AIResponseError(message, error);
+    } finally {
+      clearTimeout(timer);
+    }
+    const raw = await response.text();
+    if (!response.ok) throw new AIResponseError(`AI provider returned HTTP ${response.status}: ${raw.slice(0, 500)}`);
+    let payload;
+    try { payload = JSON.parse(raw); } catch { payload = raw; }
+    const text = extractResponseText(payload);
+    if (!text) throw new AIResponseError('The AI provider response did not contain recognizable generated content.');
+    return parseJsonResponse(text);
+  }
+}

package/src/ai/mock.js

@@ -0,0 +1,77 @@
+function section(heading, paragraphs, bullets = []) {
+  return { heading, paragraphs, bullets };
+}
+
+function inferName(project, scan) {
+  if (project.packageName) return project.packageName.replace(/^@[^/]+\//, '');
+  const readme = scan.documents.find((doc) => /readme\.md$/i.test(doc.path));
+  const match = readme?.content.match(/^#\s+(.+)$/m);
+  return match?.[1].trim() || 'This Service';
+}
+
+export function createMockResponse({ project, scan, country, date }) {
+  const name = inferName(project, scan);
+  const operator = `the operator of ${name}`;
+  return {
+    projectName: name,
+    summary: `${name} is the software service described in the project's supplied documentation.`,
+    privacyPolicy: {
+      title: 'Privacy Policy',
+      lastUpdated: date,
+      intro: [
+        `This Privacy Policy explains how ${operator} (\"we\", \"us\", or \"our\") handles information when you use ${name}. It is a draft generated from the available project documentation and should be reviewed by the operator before publication.`,
+        `This policy is intended for users in ${country}. If you use the service from another location, additional local rights may apply.`
+      ],
+      sections: [
+        section('Information We Handle', [
+          'We may handle information you provide directly, such as account, profile, support, or form details, when those features are available. We may also receive limited technical information needed to operate and protect the service, such as device, browser, log, and diagnostic data.',
+          'The exact information collected depends on the features you choose to use. We do not intend to collect information that is not reasonably required for those features.'
+        ]),
+        section('How We Use Information', ['We use information only for legitimate service purposes, including:'], [
+          'providing, maintaining, and improving the service;',
+          'responding to requests and communicating about the service;',
+          'protecting users, preventing abuse, and troubleshooting problems;',
+          'meeting applicable legal and regulatory obligations.'
+        ]),
+        section('Consent and Lawful Handling', [`Where ${country} law requires consent, we will request clear consent before handling personal data and allow it to be withdrawn. In other cases, we handle data when necessary to provide the requested service, comply with law, or pursue a legitimate purpose permitted by law.`]),
+        section('Cookies and Similar Technologies', ['The service may use essential browser storage or similar technologies to maintain sessions, preferences, and security. Any non-essential analytics or advertising technology should be disclosed and, where required, enabled only after consent.']),
+        section('Service Providers and Disclosures', ['We may share information with vendors that host, secure, support, or otherwise process data for the service under appropriate instructions. We may also disclose information when legally required, to protect rights and safety, or as part of a business transfer. We do not authorize service providers to use personal data for unrelated purposes.']),
+        section('International Processing', [`Information may be processed outside your state or country where our infrastructure or service providers operate. When required by the laws of ${country}, we use appropriate safeguards for such transfers.`]),
+        section('Data Retention', ['We retain personal data only for as long as needed for the purposes described here, including providing the service, resolving disputes, maintaining security, and complying with law. Retention periods vary according to the type of information and the reason it is held.']),
+        section('Security', ['We use reasonable administrative, technical, and organizational safeguards appropriate to the service. No method of storage or transmission is completely secure, so absolute security cannot be guaranteed.']),
+        section('Your Choices and Rights', [`Depending on applicable law in ${country}, you may be able to access, correct, update, erase, or obtain information about your personal data; withdraw consent; object to certain handling; or raise a grievance. Requests can be made using the contact method published with the service. We may need to verify your identity.`]),
+        section("Children's Privacy", ['The service is not directed to children unless the product documentation expressly says otherwise. If we learn that personal data of a child was collected without authorization required by applicable law, we will take reasonable steps to remove it.']),
+        section('Changes to This Policy', ['We may update this policy as the service or applicable requirements change. The revised version will show a new effective date, and material changes may be communicated through the service or another appropriate channel.']),
+        section('Contact and Grievances', [`Questions, privacy requests, and grievances should be sent through the contact channel published by ${operator}. The operator should add a working email or postal address here before releasing this page.`])
+      ]
+    },
+    termsOfUse: {
+      title: 'Terms of Use',
+      lastUpdated: date,
+      intro: [
+        `These Terms of Use govern access to and use of ${name}. By using the service, you agree to these terms. If you do not agree, do not use the service.`,
+        'These terms are a generated draft and should be reviewed and completed by the operator before publication.'
+      ],
+      sections: [
+        section('Eligibility and Authority', ['You must be legally capable of entering into these terms. If you use the service for an organization, you confirm that you have authority to bind that organization. Additional age or guardian requirements under applicable law continue to apply.']),
+        section('The Service', [`${name} provides the functionality described through its product interface and documentation. Features may evolve, and we may change, suspend, or discontinue parts of the service where reasonably necessary.`]),
+        section('Accounts and Security', ['If an account is required, provide accurate information, protect your credentials, and promptly report suspected unauthorized use. You are responsible for activity under your account to the extent permitted by law.']),
+        section('Acceptable Use', ['You may not misuse the service. In particular, you must not:'], [
+          'violate law or the rights of another person;',
+          'upload malicious code or interfere with service security or availability;',
+          'attempt unauthorized access, scraping, reverse engineering, or circumvention of safeguards except where law expressly permits it;',
+          'use the service to distribute deceptive, abusive, or unlawful material.'
+        ]),
+        section('Your Content', ['You retain ownership of content you submit. You grant us only the limited rights needed to host, process, display, and transmit that content to operate the service. You confirm that you have the rights needed to submit it and that it does not violate law or third-party rights.']),
+        section('Our Intellectual Property', [`The service, software, branding, and operator-provided content are owned by ${operator} or its licensors and are protected by applicable intellectual-property laws. These terms grant only a limited, revocable, non-transferable right to use the service as intended.`]),
+        section('Third-Party Services', ['The service may link to or depend on third-party products. Their terms and privacy practices apply to their services, and we are not responsible for third-party content or availability except where applicable law provides otherwise.']),
+        section('Disclaimers', ['To the extent permitted by law, the service is provided on an “as is” and “as available” basis. We do not promise uninterrupted or error-free operation. Nothing in these terms excludes warranties or consumer rights that cannot legally be excluded.']),
+        section('Limitation of Liability', ['To the maximum extent permitted by law, the operator will not be liable for indirect, incidental, special, consequential, or punitive losses arising from the service. Any enforceable limitation must be applied consistently with mandatory consumer and other applicable laws.']),
+        section('Suspension and Termination', ['We may restrict or end access for a material violation of these terms, risk to users or the service, legal requirements, or discontinuation. You may stop using the service at any time. Provisions that by their nature should survive termination will remain effective.']),
+        section('Governing Law and Disputes', [`These terms are governed by the applicable laws of ${country}, without overriding mandatory protections available to you. The operator should specify its state, courts, and any required dispute process before publication.`]),
+        section('Changes to These Terms', ['We may update these terms when the service or legal requirements change. We will post the revised terms with a new effective date and provide additional notice where required. Continued use after the effective date constitutes acceptance only to the extent permitted by law.']),
+        section('Contact', [`Questions about these terms should be sent through the contact channel published by ${operator}. The operator should add complete legal identity and contact details before releasing this page.`])
+      ]
+    }
+  };
+}

package/src/ai/prompt.js

@@ -0,0 +1,32 @@
+import { formatScanForPrompt } from '../scanner.js';
+
+export function buildPrompt({ scan, project, country, theme, date }) {
+  return `You are a careful legal-document drafting assistant and web content architect.
+
+Create a privacy policy and terms of use for the software project described below. The documents must be tailored to the project's actual features and data practices, use plain language, and be localized for ${country}. Do not claim certifications, security controls, payment flows, data collection, or third-party services unless supported by the supplied project context. Where facts are unknown, phrase the text conservatively and tell users to contact the operator. Include the important topics normally expected for this project and jurisdiction. This is a draft for operator/legal review, not a claim of legal advice.
+
+Project technology: ${project.framework}${project.router !== 'none' ? ` (${project.router})` : ''}
+Page color theme: primary ${theme.primary}, background ${theme.background}, text ${theme.text}
+Effective date: ${date}
+
+Return ONLY valid JSON with exactly this shape (no Markdown fence):
+{
+  "projectName": "string",
+  "summary": "one-sentence project description",
+  "privacyPolicy": {
+    "title": "Privacy Policy",
+    "lastUpdated": "${date}",
+    "intro": ["paragraph"],
+    "sections": [{"heading": "string", "paragraphs": ["string"], "bullets": ["optional bullet"]}]
+  },
+  "termsOfUse": {
+    "title": "Terms of Use",
+    "lastUpdated": "${date}",
+    "intro": ["paragraph"],
+    "sections": [{"heading": "string", "paragraphs": ["string"], "bullets": ["optional bullet"]}]
+  }
+}
+
+PROJECT CONTEXT:
+${formatScanForPrompt(scan)}`;
+}

package/src/colors.js

@@ -0,0 +1,69 @@
+import path from 'node:path';
+import { readdir, readFile } from 'node:fs/promises';
+import { SKIP_DIRECTORIES } from './utils.js';
+
+const COLOR_PATTERN = /#[0-9a-f]{3,8}\b|(?:rgb|hsl)a?\([^)]*\)/gi;
+const RELEVANT_PATTERN = /(?:home|index|header|footer|navbar|nav|layout|app|global|theme).*(?:css|scss|sass|less|jsx?|tsx?|html?)$/i;
+const DEFAULT_THEME = { primary: '#2563eb', background: '#f8fafc', surface: '#ffffff', text: '#172033', muted: '#526072', border: '#dce3ec' };
+
+async function collect(directory, depth = 0, output = []) {
+  if (depth > 4 || output.length >= 25) return output;
+  let entries;
+  try { entries = await readdir(directory, { withFileTypes: true }); } catch { return output; }
+  for (const entry of entries) {
+    if (output.length >= 25) break;
+    if (entry.isDirectory() && !SKIP_DIRECTORIES.has(entry.name) && !entry.name.startsWith('.')) {
+      await collect(path.join(directory, entry.name), depth + 1, output);
+    } else if (entry.isFile() && RELEVANT_PATTERN.test(entry.name)) {
+      output.push(path.join(directory, entry.name));
+    }
+  }
+  return output;
+}
+
+function normalize(color) {
+  return color.toLowerCase();
+}
+
+function luminance(hex) {
+  if (!/^#[0-9a-f]{6}$/i.test(hex)) return 0.5;
+  const values = [1, 3, 5].map((i) => parseInt(hex.slice(i, i + 2), 16) / 255)
+    .map((v) => v <= 0.03928 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4);
+  return 0.2126 * values[0] + 0.7152 * values[1] + 0.0722 * values[2];
+}
+
+function expandHex(value) {
+  if (!/^#[0-9a-f]{3}$/i.test(value)) return value;
+  return `#${value.slice(1).split('').map((char) => char + char).join('')}`;
+}
+
+function isUsableHex(value) {
+  return /^#[0-9a-f]{6}$/i.test(expandHex(value));
+}
+
+export async function detectTheme(root) {
+  const files = await collect(root);
+  const colors = [];
+  for (const file of files) {
+    try {
+      const source = (await readFile(file, 'utf8')).slice(0, 80_000);
+      for (const match of source.match(COLOR_PATTERN) || []) {
+        const color = normalize(match);
+        if (isUsableHex(color) && !colors.includes(expandHex(color))) colors.push(expandHex(color));
+      }
+    } catch { /* use the remaining files */ }
+  }
+  if (!colors.length) return { ...DEFAULT_THEME, detected: false, sourceFiles: [] };
+  const ranked = colors.filter((color) => {
+    const light = luminance(color);
+    return light > 0.08 && light < 0.82;
+  });
+  return {
+    ...DEFAULT_THEME,
+    primary: ranked[0] || DEFAULT_THEME.primary,
+    detected: true,
+    sourceFiles: files.map((file) => path.relative(root, file))
+  };
+}
+
+export { DEFAULT_THEME };

package/src/detector.js

@@ -0,0 +1,64 @@
+import path from 'node:path';
+import { access, readdir } from 'node:fs/promises';
+import { readText, toPosix } from './utils.js';
+
+async function exists(file) {
+  try { await access(file); return true; } catch { return false; }
+}
+
+async function hasPageFiles(directory) {
+  try {
+    const entries = await readdir(directory, { withFileTypes: true });
+    return entries.some((entry) => entry.isDirectory() || /\.(jsx?|tsx?)$/.test(entry.name));
+  } catch {
+    return false;
+  }
+}
+
+export async function detectProject(root) {
+  let pkg = {};
+  try { pkg = JSON.parse(await readText(path.join(root, 'package.json'), '{}')); } catch { /* invalid package */ }
+  const dependencies = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+  const has = (name) => Boolean(dependencies[name]);
+  const typescript = await exists(path.join(root, 'tsconfig.json'));
+
+  if (has('next')) {
+    const appCandidates = ['app', 'src/app'];
+    const pagesCandidates = ['pages', 'src/pages'];
+    for (const candidate of appCandidates) {
+      if (await hasPageFiles(path.join(root, candidate))) {
+        return { framework: 'next', router: 'app', sourceDirectory: candidate, typescript, packageName: pkg.name };
+      }
+    }
+    for (const candidate of pagesCandidates) {
+      if (await hasPageFiles(path.join(root, candidate))) {
+        return { framework: 'next', router: 'pages', sourceDirectory: candidate, typescript, packageName: pkg.name };
+      }
+    }
+    return { framework: 'next', router: 'app', sourceDirectory: 'app', typescript, packageName: pkg.name };
+  }
+
+  if (has('@angular/core') || await exists(path.join(root, 'angular.json'))) {
+    return { framework: 'angular', router: 'angular', sourceDirectory: 'src/app', typescript: true, packageName: pkg.name };
+  }
+
+  if (has('react') || has('react-dom')) {
+    return {
+      framework: 'react',
+      router: has('react-router-dom') ? 'react-router' : 'none',
+      sourceDirectory: 'src',
+      typescript,
+      packageName: pkg.name
+    };
+  }
+
+  const htmlFiles = [];
+  try {
+    for (const entry of await readdir(root, { withFileTypes: true })) {
+      if (entry.isFile() && /\.html?$/i.test(entry.name)) htmlFiles.push(toPosix(entry.name));
+    }
+  } catch { /* inaccessible root is handled by caller */ }
+  return { framework: htmlFiles.length ? 'html' : 'generic', router: 'none', sourceDirectory: '.', typescript: false, packageName: pkg.name, htmlFiles };
+}
+
+export { exists };

package/src/env.js

@@ -0,0 +1,29 @@
+import path from 'node:path';
+import { readFile } from 'node:fs/promises';
+
+function unquote(value) {
+  const trimmed = value.trim();
+  if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+      (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+
+export async function loadEnv(root, target = process.env) {
+  const candidates = ['.env.local', '.env'];
+  for (const name of candidates) {
+    let source;
+    try {
+      source = await readFile(path.join(root, name), 'utf8');
+    } catch {
+      continue;
+    }
+    for (const line of source.split(/\r?\n/)) {
+      const match = line.match(/^\s*(?:export\s+)?([A-Za-z_][\w]*)\s*=\s*(.*)\s*$/);
+      if (!match || match[1] in target) continue;
+      target[match[1]] = unquote(match[2].replace(/\s+#.*$/, ''));
+    }
+  }
+  return target;
+}

package/src/errors.js

@@ -0,0 +1,21 @@
+export class PrivonError extends Error {
+  constructor(message, code = 'PRIVON_ERROR', cause) {
+    super(message, { cause });
+    this.name = 'PrivonError';
+    this.code = code;
+  }
+}
+
+export class ConfigurationError extends PrivonError {
+  constructor(message) {
+    super(message, 'CONFIGURATION_ERROR');
+    this.name = 'ConfigurationError';
+  }
+}
+
+export class AIResponseError extends PrivonError {
+  constructor(message, cause) {
+    super(message, 'AI_RESPONSE_ERROR', cause);
+    this.name = 'AIResponseError';
+  }
+}

package/src/generator.js

@@ -0,0 +1,69 @@
+import path from 'node:path';
+import { stat } from 'node:fs/promises';
+import { AIClient } from './ai/client.js';
+import { createMockResponse } from './ai/mock.js';
+import { buildPrompt } from './ai/prompt.js';
+import { detectTheme } from './colors.js';
+import { detectProject } from './detector.js';
+import { loadEnv } from './env.js';
+import { ConfigurationError } from './errors.js';
+import { normalizeGeneratedContent } from './model.js';
+import { scanProject } from './scanner.js';
+import { writePages } from './writer.js';
+
+function isoDate(value = new Date()) {
+  const date = value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(date.getTime())) throw new ConfigurationError('The effective date is invalid. Use a date accepted by JavaScript, such as 2026-09-13.');
+  return date.toISOString().slice(0, 10);
+}
+
+function mockEnabled(value) {
+  if (typeof value === 'boolean') return value;
+  return /^(?:1|true|yes)$/i.test(process.env.PRI_AI_MOCK || '');
+}
+
+export async function generateLegalPages(options = {}) {
+  const root = path.resolve(options.root || process.cwd());
+  try {
+    if (!(await stat(root)).isDirectory()) throw new Error('not a directory');
+  } catch {
+    throw new ConfigurationError(`Project root does not exist or is not a directory: ${root}`);
+  }
+
+  if (options.loadEnv !== false) await loadEnv(root);
+  const country = String(options.country || 'India').trim() || 'India';
+  const date = isoDate(options.date);
+  const [project, scan, theme] = await Promise.all([
+    detectProject(root),
+    scanProject(root, {
+      fullScan: options.fullScan,
+      maxFiles: options.maxFiles,
+      maxBytes: options.maxBytes,
+      maxFileBytes: options.maxFileBytes
+    }),
+    detectTheme(root)
+  ]);
+
+  const mock = mockEnabled(options.mock);
+  const rawContent = mock
+    ? createMockResponse({ project, scan, country, date })
+    : await (options.client || new AIClient({
+      url: options.aiUrl,
+      model: options.aiModel,
+      apiKey: options.aiApiKey,
+      provider: options.provider,
+      fetch: options.fetch,
+      maxTokens: options.maxTokens,
+      headers: options.headers
+    })).generate(buildPrompt({ scan, project, country, theme, date }));
+
+  const fallbackName = project.packageName || path.basename(root);
+  const content = normalizeGeneratedContent(rawContent, fallbackName, date);
+  const output = await writePages({
+    root, project, content, theme,
+    force: Boolean(options.force),
+    dryRun: Boolean(options.dryRun)
+  });
+
+  return { root, country, date, mock, project, scan: { files: scan.documents.map((item) => item.path), totalBytes: scan.totalBytes, truncated: scan.truncated, fullScan: scan.fullScan }, theme, content, output };
+}

package/src/index.js

@@ -0,0 +1,8 @@
+export { generateLegalPages } from './generator.js';
+export { detectProject } from './detector.js';
+export { detectTheme } from './colors.js';
+export { scanProject } from './scanner.js';
+export { AIClient, extractResponseText, parseJsonResponse } from './ai/client.js';
+export { PrivonError, ConfigurationError, AIResponseError } from './errors.js';
+
+export { generateLegalPages as default } from './generator.js';

package/src/model.js

@@ -0,0 +1,32 @@
+import { AIResponseError } from './errors.js';
+
+function strings(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => typeof item === 'string').map((item) => item.trim()).filter(Boolean);
+}
+
+function normalizeDocument(value, fallbackTitle, fallbackDate) {
+  if (!value || typeof value !== 'object') throw new AIResponseError(`AI response is missing ${fallbackTitle}.`);
+  const sections = Array.isArray(value.sections) ? value.sections.map((item) => ({
+    heading: typeof item?.heading === 'string' ? item.heading.trim() : '',
+    paragraphs: strings(item?.paragraphs),
+    bullets: strings(item?.bullets)
+  })).filter((item) => item.heading && (item.paragraphs.length || item.bullets.length)) : [];
+  if (!sections.length) throw new AIResponseError(`${fallbackTitle} did not contain any usable sections.`);
+  return {
+    title: typeof value.title === 'string' && value.title.trim() ? value.title.trim() : fallbackTitle,
+    lastUpdated: typeof value.lastUpdated === 'string' && value.lastUpdated.trim() ? value.lastUpdated.trim() : fallbackDate,
+    intro: strings(value.intro),
+    sections
+  };
+}
+
+export function normalizeGeneratedContent(value, fallbackName, date) {
+  if (!value || typeof value !== 'object') throw new AIResponseError('AI response was not an object.');
+  return {
+    projectName: typeof value.projectName === 'string' && value.projectName.trim() ? value.projectName.trim() : fallbackName,
+    summary: typeof value.summary === 'string' ? value.summary.trim() : '',
+    privacyPolicy: normalizeDocument(value.privacyPolicy, 'Privacy Policy', date),
+    termsOfUse: normalizeDocument(value.termsOfUse, 'Terms of Use', date)
+  };
+}

package/src/scanner.js

@@ -0,0 +1,97 @@
+import path from 'node:path';
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { SKIP_DIRECTORIES, toPosix } from './utils.js';
+
+const DOCUMENT_NAMES = new Set([
+  'readme.md', 'requirements.md', 'requirement.md', 'prd.md', 'plan.md',
+  'spec.md', 'specification.md', 'architecture.md', 'design.md', 'features.md',
+  'product.md', 'overview.md', 'docs.md', 'contributing.md', 'changelog.md'
+]);
+
+const CODE_EXTENSIONS = new Set([
+  '.js', '.jsx', '.mjs', '.cjs', '.ts', '.tsx', '.html', '.htm', '.css',
+  '.scss', '.sass', '.less', '.vue', '.svelte', '.json', '.yaml', '.yml',
+  '.py', '.rb', '.php', '.java', '.kt', '.go', '.rs', '.cs', '.swift',
+  '.md', '.mdx', '.txt'
+]);
+
+async function walk(root, current, files, options, depth = 0) {
+  if (files.length >= options.maxFiles || depth > options.maxDepth) return;
+  let entries;
+  try {
+    entries = await readdir(current, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  entries.sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    if (files.length >= options.maxFiles) break;
+    if (entry.isSymbolicLink()) continue;
+    const absolute = path.join(current, entry.name);
+    if (entry.isDirectory()) {
+      if (!SKIP_DIRECTORIES.has(entry.name) && !entry.name.startsWith('.')) {
+        await walk(root, absolute, files, options, depth + 1);
+      }
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    const lower = entry.name.toLowerCase();
+    const relative = toPosix(path.relative(root, absolute));
+    const extension = path.extname(lower);
+    const inDocsFolder = relative.toLowerCase().startsWith('docs/');
+    const include = options.fullScan
+      ? CODE_EXTENSIONS.has(extension)
+      : DOCUMENT_NAMES.has(lower) || (inDocsFolder && ['.md', '.mdx'].includes(extension));
+    if (include) files.push(absolute);
+  }
+}
+
+export async function scanProject(root, options = {}) {
+  const settings = {
+    fullScan: Boolean(options.fullScan),
+    maxFiles: options.maxFiles ?? (options.fullScan ? 200 : 40),
+    maxBytes: options.maxBytes ?? 350_000,
+    maxFileBytes: options.maxFileBytes ?? 40_000,
+    maxDepth: options.maxDepth ?? (options.fullScan ? 12 : 4)
+  };
+  const candidates = [];
+  await walk(root, root, candidates, settings);
+  const documents = [];
+  let totalBytes = 0;
+  let truncated = false;
+  for (const file of candidates) {
+    let fileStat;
+    try {
+      fileStat = await stat(file);
+    } catch {
+      continue;
+    }
+    if (totalBytes >= settings.maxBytes) {
+      truncated = true;
+      continue;
+    }
+    const remaining = settings.maxBytes - totalBytes;
+    let content;
+    try {
+      content = await readFile(file, 'utf8');
+    } catch {
+      continue;
+    }
+    if (content.includes('\u0000')) continue;
+    const allowed = Math.min(settings.maxFileBytes, remaining);
+    if (Buffer.byteLength(content) > allowed) {
+      content = Buffer.from(content).subarray(0, allowed).toString('utf8');
+      truncated = true;
+    }
+    totalBytes += Buffer.byteLength(content);
+    documents.push({ path: toPosix(path.relative(root, file)), content });
+  }
+  return { documents, totalBytes, truncated, fullScan: settings.fullScan };
+}
+
+export function formatScanForPrompt(scan) {
+  if (!scan.documents.length) return 'No project documentation was found.';
+  return scan.documents.map(({ path: file, content }) =>
+    `\n--- FILE: ${file} ---\n${content}`
+  ).join('\n');
+}

package/src/templates.js

@@ -0,0 +1,128 @@
+function safeJson(value) {
+  return JSON.stringify(value, null, 2).replace(/</g, '\\u003c').replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+}
+
+function reactStyles(theme, typescript) {
+  return `const styles = {
+  page: { minHeight: '100vh', background: '${theme.background}', color: '${theme.text}', padding: '48px 20px', fontFamily: 'Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif', lineHeight: 1.7 },
+  article: { maxWidth: 840, margin: '0 auto', background: '${theme.surface}', border: '1px solid ${theme.border}', borderRadius: 18, padding: 'clamp(24px, 5vw, 56px)', boxShadow: '0 18px 50px rgba(15, 23, 42, 0.08)' },
+  eyebrow: { color: '${theme.primary}', fontSize: 14, fontWeight: 700, letterSpacing: '0.08em', textTransform: 'uppercase', margin: 0 },
+  title: { fontSize: 'clamp(2rem, 5vw, 3.25rem)', letterSpacing: '-0.035em', lineHeight: 1.1, margin: '8px 0 12px' },
+  updated: { color: '${theme.muted}', fontSize: 14, marginBottom: 32 },
+  section: { marginTop: 32 },
+  heading: { fontSize: 22, lineHeight: 1.3, marginBottom: 10 },
+  paragraph: { margin: '10px 0' },
+  list: { paddingLeft: 24, margin: '10px 0' },
+  notice: { borderLeft: '4px solid ${theme.primary}', background: '${theme.background}', padding: '12px 16px', borderRadius: 6, marginBottom: 28 }
+}${typescript ? ' as const' : ''};`;
+}
+
+function reactBody() {
+  return `  return (
+    <main style={styles.page}>
+      <article style={styles.article}>
+        <p style={styles.eyebrow}>{projectName}</p>
+        <h1 style={styles.title}>{document.title}</h1>
+        <p style={styles.updated}>Effective date: {document.lastUpdated}</p>
+        <div style={styles.notice}>Please review this generated draft and add your legal identity and contact details before publishing.</div>
+        {document.intro.map((paragraph, index) => <p style={styles.paragraph} key={\`intro-\${index}\`}>{paragraph}</p>)}
+        {document.sections.map((section, index) => (
+          <section style={styles.section} key={\`section-\${index}\`}>
+            <h2 style={styles.heading}>{section.heading}</h2>
+            {section.paragraphs.map((paragraph, paragraphIndex) => <p style={styles.paragraph} key={\`p-\${paragraphIndex}\`}>{paragraph}</p>)}
+            {section.bullets.length > 0 && <ul style={styles.list}>{section.bullets.map((bullet, bulletIndex) => <li key={\`b-\${bulletIndex}\`}>{bullet}</li>)}</ul>}
+          </section>
+        ))}
+      </article>
+    </main>
+  );`;
+}
+
+export function renderReactPage({ document, projectName, theme, componentName, nextApp = false, typescript = false }) {
+  return `${nextApp ? `export const metadata = { title: ${safeJson(document.title)} };\n\n` : ''}const projectName = ${safeJson(projectName)};
+const document = ${safeJson(document)};
+
+${reactStyles(theme, typescript)}
+
+export default function ${componentName}() {
+${reactBody()}
+}
+`;
+}
+
+function escapeHtml(value) {
+  return String(value).replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;').replaceAll("'", '&#039;');
+}
+
+export function renderHtmlPage({ document, projectName, theme }) {
+  const intro = document.intro.map((item) => `<p>${escapeHtml(item)}</p>`).join('\n');
+  const sections = document.sections.map((section) => `<section>
+<h2>${escapeHtml(section.heading)}</h2>
+${section.paragraphs.map((item) => `<p>${escapeHtml(item)}</p>`).join('\n')}
+${section.bullets.length ? `<ul>${section.bullets.map((item) => `<li>${escapeHtml(item)}</li>`).join('')}</ul>` : ''}
+</section>`).join('\n');
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>${escapeHtml(document.title)} | ${escapeHtml(projectName)}</title>
+</head>
+<body style="margin:0;background:${theme.background};color:${theme.text};font-family:Inter,system-ui,-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif;line-height:1.7">
+  <main style="min-height:100vh;padding:48px 20px;box-sizing:border-box">
+    <article style="max-width:840px;margin:0 auto;background:${theme.surface};border:1px solid ${theme.border};border-radius:18px;padding:clamp(24px,5vw,56px);box-sizing:border-box;box-shadow:0 18px 50px rgba(15,23,42,.08)">
+      <p style="color:${theme.primary};font-size:14px;font-weight:700;letter-spacing:.08em;text-transform:uppercase;margin:0">${escapeHtml(projectName)}</p>
+      <h1 style="font-size:clamp(2rem,5vw,3.25rem);letter-spacing:-.035em;line-height:1.1;margin:8px 0 12px">${escapeHtml(document.title)}</h1>
+      <p style="color:${theme.muted};font-size:14px;margin-bottom:32px">Effective date: ${escapeHtml(document.lastUpdated)}</p>
+      <aside style="border-left:4px solid ${theme.primary};background:${theme.background};padding:12px 16px;border-radius:6px;margin-bottom:28px">Please review this generated draft and add your legal identity and contact details before publishing.</aside>
+      ${intro}
+      ${sections}
+    </article>
+  </main>
+</body>
+</html>
+`;
+}
+
+export function renderAngularPage({ document, projectName, theme, componentName, selector }) {
+  const json = safeJson(document);
+  return `import { CommonModule } from '@angular/common';
+import { Component } from '@angular/core';
+
+@Component({
+  selector: '${selector}',
+  standalone: true,
+  imports: [CommonModule],
+  template: \`
+    <main [ngStyle]="styles.page">
+      <article [ngStyle]="styles.article">
+        <p [ngStyle]="styles.eyebrow">{{ projectName }}</p>
+        <h1 [ngStyle]="styles.title">{{ document.title }}</h1>
+        <p [ngStyle]="styles.updated">Effective date: {{ document.lastUpdated }}</p>
+        <aside [ngStyle]="styles.notice">Please review this generated draft and add your legal identity and contact details before publishing.</aside>
+        <p *ngFor="let paragraph of document.intro">{{ paragraph }}</p>
+        <section *ngFor="let section of document.sections" [ngStyle]="styles.section">
+          <h2 [ngStyle]="styles.heading">{{ section.heading }}</h2>
+          <p *ngFor="let paragraph of section.paragraphs">{{ paragraph }}</p>
+          <ul *ngIf="section.bullets.length"><li *ngFor="let bullet of section.bullets">{{ bullet }}</li></ul>
+        </section>
+      </article>
+    </main>
+  \`
+})
+export class ${componentName} {
+  readonly projectName = ${safeJson(projectName)};
+  readonly document = ${json};
+  readonly styles = {
+    page: { minHeight: '100vh', background: '${theme.background}', color: '${theme.text}', padding: '48px 20px', fontFamily: 'Inter, system-ui, sans-serif', lineHeight: '1.7' },
+    article: { maxWidth: '840px', margin: '0 auto', background: '${theme.surface}', border: '1px solid ${theme.border}', borderRadius: '18px', padding: 'clamp(24px, 5vw, 56px)', boxShadow: '0 18px 50px rgba(15,23,42,.08)' },
+    eyebrow: { color: '${theme.primary}', fontSize: '14px', fontWeight: '700', letterSpacing: '.08em', textTransform: 'uppercase' },
+    title: { fontSize: 'clamp(2rem, 5vw, 3.25rem)', lineHeight: '1.1' },
+    updated: { color: '${theme.muted}', fontSize: '14px', marginBottom: '32px' },
+    notice: { borderLeft: '4px solid ${theme.primary}', background: '${theme.background}', padding: '12px 16px', borderRadius: '6px' },
+    section: { marginTop: '32px' },
+    heading: { fontSize: '22px' }
+  };
+}
+`;
+}

package/src/utils.js

@@ -0,0 +1,25 @@
+import path from 'node:path';
+import { readFile } from 'node:fs/promises';
+
+export const SKIP_DIRECTORIES = new Set([
+  '.git', '.next', '.nuxt', '.output', '.turbo', '.vercel',
+  'node_modules', 'dist', 'build', 'coverage', 'vendor', 'target'
+]);
+
+export function toPosix(value) {
+  return value.split(path.sep).join('/');
+}
+
+export async function readText(file, fallback) {
+  try {
+    return await readFile(file, 'utf8');
+  } catch (error) {
+    if (arguments.length > 1) return fallback;
+    throw error;
+  }
+}
+
+export function isInside(parent, child) {
+  const relative = path.relative(parent, child);
+  return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}

package/src/writer.js

@@ -0,0 +1,138 @@
+import path from 'node:path';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { exists } from './detector.js';
+import { renderAngularPage, renderHtmlPage, renderReactPage } from './templates.js';
+import { isInside, toPosix } from './utils.js';
+
+async function writeGenerated(root, relative, content, options, manifest) {
+  const absolute = path.resolve(root, relative);
+  if (!isInside(root, absolute)) throw new Error(`Refusing to write outside the project: ${relative}`);
+  const alreadyExists = await exists(absolute);
+  if (alreadyExists && !options.force) {
+    manifest.skipped.push(toPosix(relative));
+    return false;
+  }
+  if (!options.dryRun) {
+    await mkdir(path.dirname(absolute), { recursive: true });
+    await writeFile(absolute, content, 'utf8');
+  }
+  manifest.files.push(toPosix(relative));
+  return true;
+}
+
+function relativeImport(fromFile, targetWithoutExtension) {
+  let value = toPosix(path.relative(path.dirname(fromFile), targetWithoutExtension));
+  if (!value.startsWith('.')) value = `./${value}`;
+  return value;
+}
+
+async function findFirst(root, candidates) {
+  for (const relative of candidates) if (await exists(path.join(root, relative))) return relative;
+  return undefined;
+}
+
+async function integrateReactRouter(root, pages, options, manifest) {
+  const routeFile = await findFirst(root, [
+    'src/App.tsx', 'src/App.jsx', 'src/App.ts', 'src/App.js',
+    'src/routes.tsx', 'src/routes.jsx', 'src/router.tsx', 'src/router.jsx'
+  ]);
+  if (!routeFile) {
+    manifest.warnings.push('React Router was detected, but no conventional route file was found. Import the generated components and add /privacy-policy and /terms-of-use routes manually.');
+    return;
+  }
+  const absolute = path.join(root, routeFile);
+  let source = await readFile(absolute, 'utf8');
+  if (!/<Routes(?:\s|>)/.test(source)) {
+    manifest.warnings.push(`${toPosix(routeFile)} does not contain a <Routes> element; routes were not modified.`);
+    return;
+  }
+  const privacyImport = `import PrivacyPolicy from '${relativeImport(routeFile, pages.privacy)}';`;
+  const termsImport = `import TermsOfUse from '${relativeImport(routeFile, pages.terms)}';`;
+  const routeImport = "import { Route as PrivonRoute } from 'react-router-dom';";
+  const addPrivacy = !/path=["']\/privacy-policy["']/.test(source);
+  const addTerms = !/path=["']\/terms-of-use["']/.test(source);
+  if (!addPrivacy && !addTerms) return;
+  if (addPrivacy && !source.includes(privacyImport)) source = `${privacyImport}\n${source}`;
+  if (addTerms && !source.includes(termsImport)) source = `${termsImport}\n${source}`;
+  if (!source.includes(routeImport)) source = `${routeImport}\n${source}`;
+  if (addPrivacy) {
+    source = source.replace(/<Routes([^>]*)>/, `<Routes$1>\n        <PrivonRoute path="/privacy-policy" element={<PrivacyPolicy />} />`);
+  }
+  if (addTerms) {
+    source = source.replace(/<Routes([^>]*)>/, `<Routes$1>\n        <PrivonRoute path="/terms-of-use" element={<TermsOfUse />} />`);
+  }
+  if (!options.dryRun) await writeFile(absolute, source, 'utf8');
+  manifest.integrations.push(toPosix(routeFile));
+}
+
+async function integrateAngularRouter(root, pages, options, manifest) {
+  const routeFile = await findFirst(root, ['src/app/app.routes.ts', 'src/app/app-routing.module.ts']);
+  if (!routeFile) {
+    manifest.warnings.push('Angular was detected, but no app.routes.ts or app-routing.module.ts was found. Add the generated standalone components to your router manually.');
+    return;
+  }
+  const absolute = path.join(root, routeFile);
+  let source = await readFile(absolute, 'utf8');
+  if (!/(?:const|export\s+const)\s+routes\s*(?::\s*Routes)?\s*=\s*\[/.test(source)) {
+    manifest.warnings.push(`${toPosix(routeFile)} has no conventional routes array; routes were not modified.`);
+    return;
+  }
+  const privacyImport = `import { PrivacyPolicyComponent } from '${relativeImport(routeFile, pages.privacy)}';`;
+  const termsImport = `import { TermsOfUseComponent } from '${relativeImport(routeFile, pages.terms)}';`;
+  const addPrivacy = !/path:\s*["']privacy-policy["']/.test(source);
+  const addTerms = !/path:\s*["']terms-of-use["']/.test(source);
+  if (!addPrivacy && !addTerms) return;
+  if (addPrivacy && !source.includes(privacyImport)) source = `${privacyImport}\n${source}`;
+  if (addTerms && !source.includes(termsImport)) source = `${termsImport}\n${source}`;
+  const routeArray = /((?:const|export\s+const)\s+routes\s*(?::\s*Routes)?\s*=\s*\[)/;
+  if (addPrivacy) {
+    source = source.replace(routeArray, `$1\n  { path: 'privacy-policy', component: PrivacyPolicyComponent },`);
+  }
+  if (addTerms) {
+    source = source.replace(routeArray, `$1\n  { path: 'terms-of-use', component: TermsOfUseComponent },`);
+  }
+  if (!options.dryRun) await writeFile(absolute, source, 'utf8');
+  manifest.integrations.push(toPosix(routeFile));
+}
+
+export async function writePages({ root, project, content, theme, force = false, dryRun = false }) {
+  const options = { force, dryRun };
+  const manifest = { files: [], skipped: [], integrations: [], warnings: [] };
+  const common = { projectName: content.projectName, theme };
+
+  if (project.framework === 'next') {
+    const extension = project.typescript ? 'tsx' : 'jsx';
+    if (project.router === 'app') {
+      await writeGenerated(root, path.join(project.sourceDirectory, 'privacy-policy', `page.${extension}`), renderReactPage({ ...common, document: content.privacyPolicy, componentName: 'PrivacyPolicyPage', nextApp: true, typescript: project.typescript }), options, manifest);
+      await writeGenerated(root, path.join(project.sourceDirectory, 'terms-of-use', `page.${extension}`), renderReactPage({ ...common, document: content.termsOfUse, componentName: 'TermsOfUsePage', nextApp: true, typescript: project.typescript }), options, manifest);
+    } else {
+      await writeGenerated(root, path.join(project.sourceDirectory, `privacy-policy.${extension}`), renderReactPage({ ...common, document: content.privacyPolicy, componentName: 'PrivacyPolicyPage', typescript: project.typescript }), options, manifest);
+      await writeGenerated(root, path.join(project.sourceDirectory, `terms-of-use.${extension}`), renderReactPage({ ...common, document: content.termsOfUse, componentName: 'TermsOfUsePage', typescript: project.typescript }), options, manifest);
+    }
+    return manifest;
+  }
+
+  if (project.framework === 'react') {
+    const extension = project.typescript ? 'tsx' : 'jsx';
+    const privacy = path.join(project.sourceDirectory, 'pages', 'PrivacyPolicy');
+    const terms = path.join(project.sourceDirectory, 'pages', 'TermsOfUse');
+    await writeGenerated(root, `${privacy}.${extension}`, renderReactPage({ ...common, document: content.privacyPolicy, componentName: 'PrivacyPolicy', typescript: project.typescript }), options, manifest);
+    await writeGenerated(root, `${terms}.${extension}`, renderReactPage({ ...common, document: content.termsOfUse, componentName: 'TermsOfUse', typescript: project.typescript }), options, manifest);
+    if (project.router === 'react-router') await integrateReactRouter(root, { privacy, terms }, options, manifest);
+    else manifest.warnings.push('React Router was not detected. Components were generated without modifying application navigation.');
+    return manifest;
+  }
+
+  if (project.framework === 'angular') {
+    const privacy = path.join(project.sourceDirectory, 'privacy-policy', 'privacy-policy.component');
+    const terms = path.join(project.sourceDirectory, 'terms-of-use', 'terms-of-use.component');
+    await writeGenerated(root, `${privacy}.ts`, renderAngularPage({ ...common, document: content.privacyPolicy, componentName: 'PrivacyPolicyComponent', selector: 'app-privacy-policy' }), options, manifest);
+    await writeGenerated(root, `${terms}.ts`, renderAngularPage({ ...common, document: content.termsOfUse, componentName: 'TermsOfUseComponent', selector: 'app-terms-of-use' }), options, manifest);
+    await integrateAngularRouter(root, { privacy, terms }, options, manifest);
+    return manifest;
+  }
+
+  await writeGenerated(root, 'privacy-policy.html', renderHtmlPage({ ...common, document: content.privacyPolicy }), options, manifest);
+  await writeGenerated(root, 'terms-of-use.html', renderHtmlPage({ ...common, document: content.termsOfUse }), options, manifest);
+  return manifest;
+}