pnpfucius 2.0.0

package/src/predict/tools/news-tools.js

@@ -0,0 +1,130 @@
+// News tool definitions and implementations for Claude Predict
+
+import { createScorer } from '../../ai/scorer.js';
+import { createMarketGenerator } from '../../ai/market-generator.js';
+import { createNewsMonitor } from '../../monitoring/news-monitor.js';
+
+// Tool definitions for Claude API
+export const newsToolDefinitions = [
+    {
+        name: 'score_news',
+        description: 'Score a news headline for privacy relevance (0-100). High scores indicate good market potential.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                headline: {
+                    type: 'string',
+                    description: 'News headline to score'
+                },
+                summary: {
+                    type: 'string',
+                    description: 'Optional article summary for more accurate scoring'
+                }
+            },
+            required: ['headline']
+        }
+    },
+    {
+        name: 'fetch_news',
+        description: 'Fetch recent privacy-related news from monitored RSS feeds',
+        input_schema: {
+            type: 'object',
+            properties: {
+                limit: {
+                    type: 'number',
+                    description: 'Max items to return (default: 10)'
+                },
+                min_score: {
+                    type: 'number',
+                    description: 'Minimum relevance score filter (default: 0)'
+                }
+            }
+        }
+    },
+    {
+        name: 'generate_from_news',
+        description: 'Generate a prediction market from a news headline',
+        input_schema: {
+            type: 'object',
+            properties: {
+                headline: {
+                    type: 'string',
+                    description: 'News headline'
+                },
+                summary: {
+                    type: 'string',
+                    description: 'Article summary'
+                },
+                source: {
+                    type: 'string',
+                    description: 'News source'
+                }
+            },
+            required: ['headline']
+        }
+    }
+];
+
+// Tool implementations
+export async function executeNewsTool(name, input) {
+    switch (name) {
+        case 'score_news': {
+            const scorer = createScorer();
+            const result = await scorer.scoreNews({
+                title: input.headline,
+                description: input.summary || ''
+            });
+            return {
+                headline: input.headline,
+                score: result.score,
+                category: result.category,
+                urgency: result.urgency,
+                market_potential: result.marketPotential,
+                reasoning: result.reasoning
+            };
+        }
+
+        case 'fetch_news': {
+            const monitor = createNewsMonitor();
+            const items = await monitor.checkFeeds();
+            const limit = input.limit || 10;
+            const minScore = input.min_score || 0;
+
+            // Score items if filtering by score
+            let scoredItems = items;
+            if (minScore > 0) {
+                const scorer = createScorer();
+                scoredItems = [];
+                for (const item of items.slice(0, 20)) {
+                    const score = await scorer.scoreNews(item);
+                    if (score.score >= minScore) {
+                        scoredItems.push({
+                            ...item,
+                            relevance_score: score.score,
+                            category: score.category
+                        });
+                    }
+                }
+            }
+
+            return {
+                items: scoredItems.slice(0, limit),
+                total: scoredItems.length,
+                min_score_filter: minScore
+            };
+        }
+
+        case 'generate_from_news': {
+            const generator = createMarketGenerator();
+            const result = await generator.generateFromNews({
+                title: input.headline,
+                description: input.summary || '',
+                source: input.source || 'Unknown'
+            });
+            return result;
+        }
+
+        default:
+            return { error: `Unknown news tool: ${name}` };
+    }
+}

package/src/predict/ui/renderer.js

@@ -0,0 +1,215 @@
+// Output renderer for Claude Predict
+
+import chalk from 'chalk';
+
+// Purple color definitions
+const purple = chalk.hex('#A855F7');
+const purpleBright = chalk.hex('#C084FC');
+const purpleDim = chalk.hex('#7C3AED');
+const violet = chalk.hex('#8B5CF6');
+
+/**
+ * Render markdown-like text for terminal output
+ * Simple rendering without external dependencies
+ */
+export function renderMarkdown(text) {
+    if (!text) return '';
+
+    let result = text;
+
+    // Headers
+    result = result.replace(/^### (.+)$/gm, purpleBright.bold('   $1'));
+    result = result.replace(/^## (.+)$/gm, purpleBright.bold('  $1'));
+    result = result.replace(/^# (.+)$/gm, purpleBright.bold(' $1'));
+
+    // Bold
+    result = result.replace(/\*\*(.+?)\*\*/g, chalk.bold('$1'));
+
+    // Italic
+    result = result.replace(/\*(.+?)\*/g, chalk.italic('$1'));
+
+    // Inline code
+    result = result.replace(/`([^`]+)`/g, violet('$1'));
+
+    // Code blocks (simple - just highlight)
+    result = result.replace(/```[\w]*\n([\s\S]*?)```/g, (_, code) => {
+        return purple('─'.repeat(40)) + '\n' +
+            violet(code.trim()) + '\n' +
+            purple('─'.repeat(40));
+    });
+
+    // Lists
+    result = result.replace(/^- (.+)$/gm, purple('  ◆') + ' $1');
+    result = result.replace(/^\d+\. (.+)$/gm, (_, item) => purple('  ◆') + ' ' + item);
+
+    // Links [text](url)
+    result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g,
+        purpleBright.underline('$1') + chalk.dim(' ($2)')
+    );
+
+    // Blockquotes
+    result = result.replace(/^> (.+)$/gm, purple('  │ ') + chalk.italic('$1'));
+
+    // Horizontal rules
+    result = result.replace(/^---$/gm, purple('─'.repeat(50)));
+
+    return result;
+}
+
+/**
+ * Format tool result for display
+ */
+export function formatToolResult(toolName, result) {
+    const lines = [];
+
+    lines.push(purpleDim(`  ┌─ ${toolName} ─────────────────────`));
+
+    if (result.error) {
+        lines.push(chalk.red(`  │ Error: ${result.error}`));
+    } else {
+        // Format based on tool type
+        const formatted = formatResultByType(toolName, result);
+        for (const line of formatted.split('\n')) {
+            lines.push(purpleDim('  │ ') + line);
+        }
+    }
+
+    lines.push(purpleDim('  └' + '─'.repeat(40)));
+
+    return lines.join('\n');
+}
+
+/**
+ * Format result based on tool type
+ */
+function formatResultByType(toolName, result) {
+    switch (toolName) {
+        case 'create_market':
+            return formatMarketCreation(result);
+        case 'generate_market':
+            return formatMarketIdea(result);
+        case 'list_markets':
+            return formatMarketList(result);
+        case 'score_news':
+            return formatNewsScore(result);
+        case 'get_stats':
+            return formatStats(result);
+        case 'run_command':
+            return formatCommandResult(result);
+        default:
+            return JSON.stringify(result, null, 2);
+    }
+}
+
+function formatMarketCreation(result) {
+    if (!result.success) return chalk.red('Market creation failed');
+
+    return [
+        purple('✓ Market created successfully!'),
+        '',
+        `${chalk.dim('Question:')} ${result.question}`,
+        `${chalk.dim('Address:')}  ${violet(result.market)}`,
+        `${chalk.dim('Signature:')} ${chalk.gray(result.signature?.slice(0, 20) + '...')}`,
+        `${chalk.dim('Duration:')} ${result.duration_days} days`,
+        `${chalk.dim('Liquidity:')} ${result.liquidity_usdc} USDC`,
+        `${chalk.dim('Network:')}  ${result.network}`
+    ].join('\n');
+}
+
+function formatMarketIdea(result) {
+    if (result.markets) {
+        return result.markets.map((m, i) =>
+            `${i + 1}. ${chalk.bold(m.question)}\n` +
+            `   ${chalk.dim('Category:')} ${m.category} | ` +
+            `${chalk.dim('Duration:')} ${m.durationDays}d | ` +
+            `${chalk.dim('Liquidity:')} ${m.suggestedLiquidity} USDC`
+        ).join('\n\n');
+    }
+
+    return [
+        chalk.bold(result.question),
+        '',
+        `${chalk.dim('Category:')} ${result.category}`,
+        `${chalk.dim('Duration:')} ${result.durationDays} days`,
+        `${chalk.dim('Suggested Liquidity:')} ${result.suggestedLiquidity} USDC`,
+        result.reasoning ? `${chalk.dim('Reasoning:')} ${result.reasoning}` : ''
+    ].filter(Boolean).join('\n');
+}
+
+function formatMarketList(result) {
+    if (!result.markets || result.markets.length === 0) {
+        return chalk.dim('No markets found');
+    }
+
+    return result.markets.map(m =>
+        `• ${chalk.bold(m.question?.slice(0, 50) || 'Unknown')}${m.question?.length > 50 ? '...' : ''}\n` +
+        `  ${chalk.dim(m.address?.slice(0, 20) + '...')} | ${m.status || 'unknown'}`
+    ).join('\n');
+}
+
+function formatNewsScore(result) {
+    const scoreColor = result.score >= 70 ? chalk.green :
+        result.score >= 40 ? chalk.yellow : chalk.red;
+
+    return [
+        `${chalk.dim('Score:')} ${scoreColor(result.score + '/100')}`,
+        `${chalk.dim('Category:')} ${result.category}`,
+        `${chalk.dim('Urgency:')} ${result.urgency}`,
+        `${chalk.dim('Market Potential:')} ${result.market_potential ? 'High' : 'Low'}`,
+        result.reasoning ? `${chalk.dim('Analysis:')} ${result.reasoning}` : ''
+    ].filter(Boolean).join('\n');
+}
+
+function formatStats(result) {
+    return [
+        `${chalk.dim('Period:')} ${result.period || 'all'}`,
+        `${chalk.dim('Total Markets:')} ${result.totalMarkets || 0}`,
+        `${chalk.dim('Active:')} ${result.activeMarkets || 0}`,
+        `${chalk.dim('Resolved:')} ${result.resolvedMarkets || 0}`
+    ].join('\n');
+}
+
+function formatCommandResult(result) {
+    const status = result.success
+        ? chalk.green('✓ Success')
+        : chalk.red(`✗ Exit code ${result.exit_code}`);
+
+    let output = status;
+    if (result.stdout) {
+        output += '\n' + result.stdout;
+    }
+    if (result.stderr && !result.success) {
+        output += '\n' + chalk.red(result.stderr);
+    }
+    return output;
+}
+
+/**
+ * Print a spinner message
+ */
+export function printSpinner(message) {
+    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    let i = 0;
+
+    return setInterval(() => {
+        process.stdout.write(`\r${purple(frames[i++ % frames.length])} ${message}`);
+    }, 80);
+}
+
+/**
+ * Stop spinner and clear line
+ */
+export function stopSpinner(spinner, message = '') {
+    clearInterval(spinner);
+    process.stdout.write('\r' + ' '.repeat(60) + '\r');
+    if (message) {
+        console.log(message);
+    }
+}
+
+/**
+ * Print tool usage indicator
+ */
+export function printToolUse(toolName) {
+    console.log(purpleDim(`\n  ◆ ${toolName}`));
+}

package/src/predict/ui/welcome.js

@@ -0,0 +1,146 @@
+// Welcome screen for PNPFUCIUS - The PNP Exchange CLI
+
+import chalk from 'chalk';
+import { getConfig } from '../../config.js';
+
+// Purple color definitions
+const purple = chalk.hex('#A855F7');
+const purpleBright = chalk.hex('#C084FC');
+const purpleDim = chalk.hex('#7C3AED');
+const purpleBold = chalk.hex('#A855F7').bold;
+const violet = chalk.hex('#8B5CF6');
+
+const LOGO = `
+${purple('╔════════════════════════════════════════════════════════════════════════╗')}
+${purple('║')}                                                                        ${purple('║')}
+${purple('║')}  ${purpleBright('██████╗ ███╗   ██╗██████╗ ███████╗██╗   ██╗ ██████╗██╗██╗   ██╗███████╗')}  ${purple('║')}
+${purple('║')}  ${purpleBright('██╔══██╗████╗  ██║██╔══██╗██╔════╝██║   ██║██╔════╝██║██║   ██║██╔════╝')}  ${purple('║')}
+${purple('║')}  ${purpleBright('██████╔╝██╔██╗ ██║██████╔╝█████╗  ██║   ██║██║     ██║██║   ██║███████╗')}  ${purple('║')}
+${purple('║')}  ${purpleBright('██╔═══╝ ██║╚██╗██║██╔═══╝ ██╔══╝  ██║   ██║██║     ██║██║   ██║╚════██║')}  ${purple('║')}
+${purple('║')}  ${purpleBright('██║     ██║ ╚████║██║     ██║     ╚██████╔╝╚██████╗██║╚██████╔╝███████║')}  ${purple('║')}
+${purple('║')}  ${purpleBright('╚═╝     ╚═╝  ╚═══╝╚═╝     ╚═╝      ╚═════╝  ╚═════╝╚═╝ ╚═════╝ ╚══════╝')}  ${purple('║')}
+${purple('║')}                                                                        ${purple('║')}
+${purple('║')}  ${violet('        "The wise trader predicts with patience"')}                     ${purple('║')}
+${purple('║')}                                                                        ${purple('║')}
+${purple('╚════════════════════════════════════════════════════════════════════════╝')}
+`;
+
+export function printWelcome(options = {}) {
+    const config = getConfig();
+    const walletKey = config.walletKey;
+    const walletDisplay = walletKey
+        ? `${walletKey.slice(0, 6)}...${walletKey.slice(-4)}`
+        : chalk.yellow('Not configured');
+
+    console.clear();
+
+    // Logo
+    console.log(LOGO);
+
+    // Tagline
+    console.log(purpleDim('  ◆ The PNP Exchange CLI'));
+    console.log(chalk.dim('  ◆ Create, Trade, and Settle Prediction Markets on Solana'));
+    console.log();
+
+    // Status bar
+    const networkColor = config.isMainnet ? chalk.red : chalk.green;
+    const networkLabel = config.isMainnet ? 'MAINNET' : 'DEVNET';
+
+    console.log(purple('  ┌' + '─'.repeat(62) + '┐'));
+    console.log(purple('  │') +
+        `  ${chalk.dim('Network')} ${networkColor.bold(networkLabel.padEnd(8))}` +
+        `${chalk.dim('│')} ` +
+        `${chalk.dim('Wallet')} ${chalk.white(walletDisplay.padEnd(16))}` +
+        `${chalk.dim('│')} ` +
+        `${chalk.dim('Helius')} ${config.heliusKey ? chalk.green('●') : chalk.yellow('○')}  ` +
+        purple('│')
+    );
+    console.log(purple('  └' + '─'.repeat(62) + '┘'));
+    console.log();
+
+    // Help hint
+    console.log(chalk.dim('  Type a message or use ') + purple('/help') + chalk.dim(' for commands'));
+    console.log();
+}
+
+export function printHelp() {
+    console.log();
+    console.log(purpleBold('  PNPFUCIUS Commands'));
+    console.log(purple('  ' + '─'.repeat(50)));
+    console.log();
+
+    const sections = [
+        {
+            title: 'Markets',
+            commands: [
+                ['/create [q]', 'Create AMM market'],
+                ['/p2p [q]', 'Create P2P market'],
+                ['/odds <q>', 'Market with custom odds'],
+                ['/discover', 'Browse ALL PNP markets'],
+                ['/markets', 'List your markets'],
+            ]
+        },
+        {
+            title: 'Trading',
+            commands: [
+                ['/buy', 'Buy YES/NO tokens'],
+                ['/sell', 'Sell tokens'],
+                ['/prices <addr>', 'Get market prices'],
+                ['/balance', 'Check your balances'],
+            ]
+        },
+        {
+            title: 'Settlement',
+            commands: [
+                ['/oracle <addr>', 'Get LLM settlement criteria'],
+                ['/settle', 'Settle a market'],
+                ['/redeem', 'Redeem winning position'],
+                ['/refund', 'Claim refund'],
+            ]
+        },
+        {
+            title: 'Info',
+            commands: [
+                ['/info <addr>', 'Market details'],
+                ['/config', 'Show configuration'],
+                ['/pnp', 'PNP protocol info'],
+            ]
+        },
+        {
+            title: 'System',
+            commands: [
+                ['/clear', 'Clear screen'],
+                ['/help', 'Show this help'],
+                ['/exit', 'Exit PNPFUCIUS'],
+            ]
+        }
+    ];
+
+    for (const section of sections) {
+        console.log(violet(`  ${section.title}`));
+        for (const [cmd, desc] of section.commands) {
+            console.log(`    ${purple(cmd.padEnd(16))} ${chalk.dim(desc)}`);
+        }
+        console.log();
+    }
+
+    console.log(violet('  "The market reveals truth to those who wait"'));
+    console.log();
+}
+
+export function printGoodbye() {
+    console.log();
+    console.log(purple('  ◆ Thanks for using PNPFUCIUS!'));
+    console.log(chalk.dim('  ◆ "The wise trader knows when to exit"'));
+    console.log();
+}
+
+export function printError(message) {
+    console.log();
+    console.log(chalk.red(`  ✗ Error: ${message}`));
+    console.log();
+}
+
+export function printDivider() {
+    console.log(purple('─'.repeat(60)));
+}

package/src/privacy-markets.js

@@ -0,0 +1,194 @@
+// Privacy-themed prediction market templates and AI generation logic
+
+const PRIVACY_CATEGORIES = {
+    regulation: {
+        name: 'Privacy Regulation',
+        weight: 0.25,
+        urgency: 'timely',
+        sentiment: 'neutral',
+        templates: [
+            'Will {country} pass comprehensive privacy legislation by {date}?',
+            'Will GDPR fines exceed ${amount}B in {year}?',
+            'Will the US pass a federal privacy law by end of {year}?',
+            'Will {company} face privacy-related regulatory action by {date}?',
+            'Will any G7 nation ban end-to-end encryption by {date}?',
+            'Will the SEC take enforcement action against a privacy protocol by {date}?',
+            'Will OFAC add new privacy protocols to sanctions list by {date}?',
+            'Will {country} implement mandatory KYC for self-custody wallets by {date}?',
+            'Will the Tornado Cash developer case result in acquittal by {date}?',
+            'Will any country legalize privacy-preserving payments by {date}?'
+        ]
+    },
+    technology: {
+        name: 'Privacy Technology',
+        weight: 0.30,
+        urgency: 'evergreen',
+        sentiment: 'bullish',
+        templates: [
+            'Will zkSync TVL exceed ${amount}B by {date}?',
+            'Will Tornado Cash sanctions be lifted by {date}?',
+            'Will a major wallet integrate confidential transactions by {date}?',
+            'Will homomorphic encryption see mainstream blockchain adoption by {year}?',
+            'Will Solana native ZK proofs go live on mainnet by {date}?',
+            'Will any privacy coin enter top 10 market cap by {date}?',
+            'Will Light Protocol TVL exceed ${amount}M by {date}?',
+            'Will Solana Token-2022 confidential transfers see significant adoption by {date}?',
+            'Will a ZK-rollup process over 1000 TPS on mainnet by {date}?',
+            'Will Aztec Network launch on mainnet by {date}?',
+            'Will any major DEX implement private swaps by {date}?',
+            'Will RAILGUN protocol TVL exceed ${amount}M by {date}?',
+            'Will Zcash implement a major protocol upgrade by {date}?',
+            'Will any L2 implement native confidential transactions by {date}?',
+            'Will a privacy-focused stablecoin reach ${amount}M market cap by {date}?'
+        ]
+    },
+    adoption: {
+        name: 'Privacy Adoption',
+        weight: 0.25,
+        urgency: 'timely',
+        sentiment: 'bullish',
+        templates: [
+            'Will Signal exceed {amount}M monthly active users by {date}?',
+            'Will a major exchange delist all privacy coins by {date}?',
+            'Will privacy-preserving identity solutions see enterprise adoption by {year}?',
+            'Will any Fortune 500 company adopt ZK proofs for supply chain by {date}?',
+            'Will confidential transactions become default on any top 20 chain by {date}?',
+            'Will Brave browser exceed {amount}M monthly active users by {date}?',
+            'Will ProtonMail reach {amount}M paid subscribers by {date}?',
+            'Will any major social platform add E2E encryption for DMs by {date}?',
+            'Will hardware wallets with privacy features exceed {amount}M units sold by {date}?',
+            'Will a privacy-focused search engine enter top 5 globally by {date}?'
+        ]
+    },
+    events: {
+        name: 'Privacy Events',
+        weight: 0.20,
+        urgency: 'breaking',
+        sentiment: 'neutral',
+        templates: [
+            'Will there be a major data breach affecting 100M+ users by {date}?',
+            'Will any government agency be caught using unauthorized surveillance by {date}?',
+            'Will a privacy-focused project win a major hackathon prize by {date}?',
+            'Will Vitalik publicly endorse a specific privacy solution by {date}?',
+            'Will the Solana Privacy Hackathon see over {amount} submissions?',
+            'Will a major privacy researcher receive significant recognition by {date}?',
+            'Will any privacy protocol suffer a major exploit by {date}?',
+            'Will a whistleblower reveal new government surveillance programs by {date}?',
+            'Will any major tech CEO publicly advocate for privacy by {date}?',
+            'Will a privacy-themed movie or documentary reach mainstream audiences by {date}?'
+        ]
+    }
+};
+
+const FILL_DATA = {
+    countries: ['USA', 'EU', 'UK', 'Japan', 'South Korea', 'Australia', 'Canada', 'Brazil'],
+    companies: ['Meta', 'Google', 'Apple', 'Microsoft', 'Amazon', 'ByteDance', 'OpenAI', 'Coinbase'],
+    amounts: ['1', '5', '10', '50', '100', '500'],
+    smallAmounts: ['10', '25', '50', '100', '250']
+};
+
+function getRandomElement(arr) {
+    return arr[Math.floor(Math.random() * arr.length)];
+}
+
+function getRandomDate(minDays = 14, maxDays = 180) {
+    const days = minDays + Math.floor(Math.random() * (maxDays - minDays));
+    const date = new Date();
+    date.setDate(date.getDate() + days);
+    
+    const months = ['January', 'February', 'March', 'April', 'May', 'June', 
+                    'July', 'August', 'September', 'October', 'November', 'December'];
+    return `${months[date.getMonth()]} ${date.getFullYear()}`;
+}
+
+function getEndOfYear() {
+    const now = new Date();
+    const currentYear = now.getFullYear();
+    const nextYear = now.getMonth() > 9 ? currentYear + 1 : currentYear;
+    return nextYear.toString();
+}
+
+function fillTemplate(template) {
+    let filled = template;
+    
+    filled = filled.replace('{country}', getRandomElement(FILL_DATA.countries));
+    filled = filled.replace('{company}', getRandomElement(FILL_DATA.companies));
+    filled = filled.replace('{amount}', getRandomElement(FILL_DATA.amounts));
+    filled = filled.replace('{date}', getRandomDate());
+    filled = filled.replace('{year}', getEndOfYear());
+    
+    if (filled.includes('{amount}')) {
+        filled = filled.replace('{amount}', getRandomElement(FILL_DATA.smallAmounts));
+    }
+    
+    return filled;
+}
+
+function selectCategory() {
+    const rand = Math.random();
+    let cumulative = 0;
+    
+    for (const [key, category] of Object.entries(PRIVACY_CATEGORIES)) {
+        cumulative += category.weight;
+        if (rand < cumulative) {
+            return { key, category };
+        }
+    }
+    
+    return { key: 'technology', category: PRIVACY_CATEGORIES.technology };
+}
+
+export function generatePrivacyMarket() {
+    const { key, category } = selectCategory();
+    const template = getRandomElement(category.templates);
+    const question = fillTemplate(template);
+    
+    const durationDays = 14 + Math.floor(Math.random() * 166);
+    
+    return {
+        question,
+        category: category.name,
+        categoryKey: key,
+        durationDays,
+        suggestedLiquidity: key === 'events' ? 500000n : 1000000n
+    };
+}
+
+export function generateMultipleMarkets(count = 5) {
+    const markets = [];
+    const usedQuestions = new Set();
+    
+    while (markets.length < count) {
+        const market = generatePrivacyMarket();
+        if (!usedQuestions.has(market.question)) {
+            usedQuestions.add(market.question);
+            markets.push(market);
+        }
+    }
+    
+    return markets;
+}
+
+export function getMarketsByCategory(categoryKey) {
+    const category = PRIVACY_CATEGORIES[categoryKey];
+    if (!category) {
+        throw new Error(`Unknown category: ${categoryKey}`);
+    }
+    
+    return category.templates.map(template => ({
+        question: fillTemplate(template),
+        category: category.name,
+        categoryKey
+    }));
+}
+
+export function listCategories() {
+    return Object.entries(PRIVACY_CATEGORIES).map(([key, cat]) => ({
+        key,
+        name: cat.name,
+        weight: cat.weight,
+        templateCount: cat.templates.length
+    }));
+}
+
+export { PRIVACY_CATEGORIES };