pnpfucius 2.0.0

package/src/predict/slash-commands.js

@@ -0,0 +1,361 @@
+// Slash command handlers for PNPFUCIUS
+
+import chalk from 'chalk';
+import { printHelp, printGoodbye, printWelcome, printDivider } from './ui/welcome.js';
+import { executeTool, getToolsByCategory } from './tools/index.js';
+import { getConfig } from '../config.js';
+
+// Purple color definitions
+const purple = chalk.hex('#A855F7');
+const purpleBright = chalk.hex('#C084FC');
+const purpleDim = chalk.hex('#7C3AED');
+const violet = chalk.hex('#8B5CF6');
+
+/**
+ * Handle slash commands
+ * @param {string} input - User input
+ * @param {object} context - Command context (agent instance, etc.)
+ * @returns {boolean} True if handled, false if not a command
+ */
+export async function handleSlashCommand(input, context = {}) {
+    const trimmed = input.trim();
+
+    if (!trimmed.startsWith('/')) {
+        return false;
+    }
+
+    const [command, ...args] = trimmed.slice(1).split(' ');
+    const argString = args.join(' ');
+    const { agent, executeTool: execTool } = context;
+
+    switch (command.toLowerCase()) {
+        case 'help':
+        case 'h':
+        case '?':
+            printHelp();
+            return true;
+
+        case 'exit':
+        case 'quit':
+        case 'q':
+            printGoodbye();
+            process.exit(0);
+
+        case 'clear':
+        case 'cls':
+            printWelcome();
+            return true;
+
+        case 'config':
+            await showConfig();
+            return true;
+
+        // ========== MARKET COMMANDS ==========
+
+        case 'discover':
+        case 'explore':
+        case 'markets':
+            const version = args[0] || 'all';
+            if (execTool) {
+                await execTool('discover_all_markets', { version });
+            }
+            return true;
+
+        case 'create':
+            if (argString) {
+                if (execTool) {
+                    await execTool('create_market', {
+                        question: argString,
+                        liquidity_usdc: 1,
+                        duration_days: 30
+                    });
+                }
+            } else {
+                console.log(purpleDim('\n  Usage: /create <market question>'));
+                console.log(chalk.dim('  Example: /create Will BTC reach $100k by 2025?'));
+            }
+            return true;
+
+        case 'p2p':
+            if (argString) {
+                if (execTool) {
+                    await execTool('create_p2p_market_simple', {
+                        question: argString,
+                        side: 'yes',
+                        amount_usdc: 1
+                    });
+                }
+            } else {
+                console.log(purpleDim('\n  Usage: /p2p <market question>'));
+                console.log(chalk.dim('  Example: /p2p Will ETH flip BTC in 2025?'));
+            }
+            return true;
+
+        case 'odds':
+            if (args.length >= 2) {
+                const oddsPercent = parseInt(args[0]);
+                const question = args.slice(1).join(' ');
+                if (execTool && !isNaN(oddsPercent)) {
+                    await execTool('create_amm_market_with_odds', {
+                        question,
+                        yes_odds_percent: oddsPercent,
+                        liquidity_usdc: 1
+                    });
+                }
+            } else {
+                console.log(purpleDim('\n  Usage: /odds <percent> <question>'));
+                console.log(chalk.dim('  Example: /odds 70 Will SOL reach $500?'));
+            }
+            return true;
+
+        case 'info':
+            if (argString) {
+                if (execTool) {
+                    await execTool('get_market_info', { market_address: argString });
+                }
+            } else {
+                console.log(purpleDim('\n  Usage: /info <market_address>'));
+            }
+            return true;
+
+        // ========== TRADING COMMANDS ==========
+
+        case 'buy':
+            if (args.length >= 3) {
+                if (execTool) {
+                    await execTool('buy_tokens', {
+                        market_address: args[0],
+                        side: args[1],
+                        amount_usdc: parseFloat(args[2])
+                    });
+                }
+            } else {
+                console.log(purpleDim('\n  Usage: /buy <market_address> <yes|no> <usdc_amount>'));
+                console.log(chalk.dim('  Example: /buy 7xKXw9... yes 10'));
+            }
+            return true;
+
+        case 'sell':
+            if (args.length >= 3) {
+                if (execTool) {
+                    await execTool('sell_tokens', {
+                        market_address: args[0],
+                        side: args[1],
+                        amount: parseFloat(args[2])
+                    });
+                }
+            } else {
+                console.log(purpleDim('\n  Usage: /sell <market_address> <yes|no> <token_amount>'));
+            }
+            return true;
+
+        case 'prices':
+        case 'price':
+            if (argString) {
+                if (execTool) {
+                    await execTool('get_market_prices', { market_address: argString });
+                }
+            } else {
+                console.log(purpleDim('\n  Usage: /prices <market_address>'));
+            }
+            return true;
+
+        case 'balance':
+        case 'balances':
+            if (argString) {
+                if (execTool) {
+                    await execTool('get_balances', { market_address: argString });
+                }
+            } else {
+                console.log(purpleDim('\n  Usage: /balance <market_address>'));
+            }
+            return true;
+
+        // ========== SETTLEMENT COMMANDS ==========
+
+        case 'oracle':
+        case 'criteria':
+            if (argString) {
+                if (execTool) {
+                    await execTool('get_settlement_criteria', { market_address: argString });
+                }
+            } else {
+                console.log(purpleDim('\n  Usage: /oracle <market_address>'));
+                console.log(chalk.dim('  Get AI-generated settlement criteria from PNP Oracle'));
+            }
+            return true;
+
+        case 'settlement':
+        case 'resolve':
+            if (argString) {
+                if (execTool) {
+                    await execTool('get_settlement_data', { market_address: argString });
+                }
+            } else {
+                console.log(purpleDim('\n  Usage: /settlement <market_address>'));
+                console.log(chalk.dim('  Get resolution result from PNP Oracle'));
+            }
+            return true;
+
+        case 'settle':
+            if (args.length >= 2) {
+                if (execTool) {
+                    await execTool('settle_market', {
+                        market_address: args[0],
+                        outcome: args[1]
+                    });
+                }
+            } else {
+                console.log(purpleDim('\n  Usage: /settle <market_address> <yes|no>'));
+                console.log(chalk.dim('  Settle market with specified outcome (requires authority)'));
+            }
+            return true;
+
+        case 'redeem':
+            if (argString) {
+                if (execTool) {
+                    await execTool('redeem_position', { market_address: argString });
+                }
+            } else {
+                console.log(purpleDim('\n  Usage: /redeem <market_address>'));
+            }
+            return true;
+
+        case 'refund':
+            if (argString) {
+                if (execTool) {
+                    await execTool('claim_refund', { market_address: argString });
+                }
+            } else {
+                console.log(purpleDim('\n  Usage: /refund <market_address>'));
+            }
+            return true;
+
+        // ========== INFO COMMANDS ==========
+
+        case 'pnp':
+            if (execTool) {
+                await execTool('get_pnp_config', {});
+            }
+            return true;
+
+        case 'tools':
+            await showTools();
+            return true;
+
+        default:
+            console.log(chalk.yellow(`\n  Unknown command: /${command}`));
+            console.log(chalk.dim('  Type /help for available commands.'));
+            return true;
+    }
+}
+
+/**
+ * Show current configuration
+ */
+async function showConfig() {
+    const config = getConfig();
+
+    console.log();
+    console.log(purpleBright('  Configuration'));
+    console.log(purple('  ' + '─'.repeat(50)));
+    console.log();
+
+    const items = [
+        ['Network', config.isMainnet ? chalk.red('mainnet') : chalk.green('devnet')],
+        ['RPC URL', chalk.dim(config.rpcUrl.slice(0, 40) + '...')],
+        ['Helius API', config.heliusKey ? chalk.green('Configured') : chalk.yellow('Not set')],
+        ['Wallet', config.walletKey ? chalk.green('Configured') : chalk.red('Not set')],
+        ['Collateral', config.collateralToken],
+        ['Default Liquidity', config.defaultLiquidity.toString()],
+        ['Default Duration', `${config.defaultDurationDays} days`]
+    ];
+
+    for (const [key, value] of items) {
+        console.log(`  ${chalk.dim(key.padEnd(18))} ${value}`);
+    }
+
+    console.log();
+}
+
+/**
+ * Show available tools
+ */
+async function showTools() {
+    const categories = getToolsByCategory();
+
+    console.log();
+    console.log(purpleBright('  Available Tools'));
+    console.log(purple('  ' + '─'.repeat(50)));
+    console.log();
+
+    const toolCategories = {
+        'Market Creation': [
+            'create_market', 'create_p2p_market_simple',
+            'create_amm_market_with_odds', 'create_p2p_market_with_odds',
+            'create_market_with_oracle', 'create_market_from_source'
+        ],
+        'Market Discovery': [
+            'discover_all_markets', 'list_markets', 'get_market_info',
+            'get_v2_market_info', 'get_p2p_market_info', 'get_market_metadata'
+        ],
+        'Trading': [
+            'buy_tokens', 'sell_tokens', 'buy_v3_tokens',
+            'get_market_prices', 'get_balances'
+        ],
+        'Settlement (PNP Oracle)': [
+            'get_settlement_criteria', 'get_settlement_data',
+            'wait_for_settlement', 'settle_market'
+        ],
+        'Redemption': [
+            'redeem_position', 'redeem_v3_position', 'redeem_p2p_position',
+            'claim_refund', 'claim_p2p_refund'
+        ],
+        'Protocol': [
+            'get_pnp_config'
+        ]
+    };
+
+    for (const [category, tools] of Object.entries(toolCategories)) {
+        console.log(violet(`  ${category}`));
+        for (const tool of tools) {
+            console.log(`    ${purple('◆')} ${tool}`);
+        }
+        console.log();
+    }
+}
+
+/**
+ * Get list of available commands for help text
+ */
+export function getCommandList() {
+    return [
+        // Markets
+        { command: '/discover', description: 'Browse all PNP markets' },
+        { command: '/create <q>', description: 'Create AMM market' },
+        { command: '/p2p <q>', description: 'Create P2P market' },
+        { command: '/odds <% q>', description: 'Market with custom odds' },
+        { command: '/info <addr>', description: 'Market details' },
+
+        // Trading
+        { command: '/buy', description: 'Buy YES/NO tokens' },
+        { command: '/sell', description: 'Sell tokens' },
+        { command: '/prices <addr>', description: 'Get market prices' },
+        { command: '/balance <addr>', description: 'Check balances' },
+
+        // Settlement
+        { command: '/oracle <addr>', description: 'Get settlement criteria' },
+        { command: '/settlement <addr>', description: 'Get resolution data' },
+        { command: '/settle <a> <y/n>', description: 'Settle market' },
+        { command: '/redeem <addr>', description: 'Redeem position' },
+        { command: '/refund <addr>', description: 'Claim refund' },
+
+        // System
+        { command: '/pnp', description: 'PNP protocol info' },
+        { command: '/config', description: 'Show configuration' },
+        { command: '/tools', description: 'List all tools' },
+        { command: '/clear', description: 'Clear screen' },
+        { command: '/help', description: 'Show help' },
+        { command: '/exit', description: 'Exit PNPFUCIUS' }
+    ];
+}

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

@@ -0,0 +1,83 @@
+// Analytics tool definitions and implementations for Claude Predict
+
+import { createAggregator } from '../../analytics/aggregator.js';
+import { PRIVACY_CATEGORIES, listCategories } from '../../privacy-markets.js';
+
+// Tool definitions for Claude API
+export const analyticsToolDefinitions = [
+    {
+        name: 'get_stats',
+        description: 'Get market statistics and analytics',
+        input_schema: {
+            type: 'object',
+            properties: {
+                period: {
+                    type: 'string',
+                    enum: ['24h', '7d', '30d', 'all'],
+                    description: 'Time period for statistics (default: all)'
+                }
+            }
+        }
+    },
+    {
+        name: 'get_categories',
+        description: 'List available market categories with their templates and weights',
+        input_schema: {
+            type: 'object',
+            properties: {}
+        }
+    }
+];
+
+// Tool implementations
+export async function executeAnalyticsTool(name, input) {
+    switch (name) {
+        case 'get_stats': {
+            const aggregator = createAggregator();
+            const overview = await aggregator.getOverview();
+            const period = input.period || 'all';
+
+            // Calculate period-specific stats
+            let periodStats = overview;
+            if (period !== 'all') {
+                const periodMs = {
+                    '24h': 24 * 60 * 60 * 1000,
+                    '7d': 7 * 24 * 60 * 60 * 1000,
+                    '30d': 30 * 24 * 60 * 60 * 1000
+                }[period];
+
+                const cutoff = Date.now() - periodMs;
+                // Filter stats by period if aggregator supports it
+                periodStats = {
+                    ...overview,
+                    period,
+                    period_start: new Date(cutoff).toISOString()
+                };
+            }
+
+            return {
+                period,
+                ...periodStats
+            };
+        }
+
+        case 'get_categories': {
+            const categories = listCategories();
+            return {
+                categories: categories.map(cat => ({
+                    id: cat.id,
+                    name: cat.name,
+                    description: cat.description,
+                    weight: cat.weight,
+                    urgency: cat.urgency,
+                    template_count: cat.templates?.length || 0,
+                    examples: cat.templates?.slice(0, 2) || []
+                })),
+                total: categories.length
+            };
+        }
+
+        default:
+            return { error: `Unknown analytics tool: ${name}` };
+    }
+}

package/src/predict/tools/bash-tool.js

@@ -0,0 +1,87 @@
+// Bash tool definition and implementation for Claude Predict
+
+import { spawn } from 'child_process';
+
+// Tool definition for Claude API
+export const bashToolDefinition = {
+    name: 'run_command',
+    description: 'Execute a shell command and return output. Use for npm, git, and other CLI operations.',
+    input_schema: {
+        type: 'object',
+        properties: {
+            command: {
+                type: 'string',
+                description: 'The shell command to execute'
+            },
+            cwd: {
+                type: 'string',
+                description: 'Working directory for the command (default: current directory)'
+            },
+            timeout: {
+                type: 'number',
+                description: 'Timeout in milliseconds (default: 30000)'
+            }
+        },
+        required: ['command']
+    }
+};
+
+// Tool implementation
+export async function executeBashTool(name, input) {
+    if (name !== 'run_command') {
+        return { error: `Unknown bash tool: ${name}` };
+    }
+
+    const { command, cwd, timeout = 30000 } = input;
+
+    return new Promise((resolve) => {
+        const isWindows = process.platform === 'win32';
+        const shell = isWindows ? 'cmd.exe' : '/bin/sh';
+        const shellFlag = isWindows ? '/c' : '-c';
+
+        const proc = spawn(shell, [shellFlag, command], {
+            cwd: cwd || process.cwd(),
+            timeout,
+            env: { ...process.env }
+        });
+
+        let stdout = '';
+        let stderr = '';
+
+        proc.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+
+        proc.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+
+        proc.on('close', (code) => {
+            resolve({
+                command,
+                exit_code: code,
+                stdout: stdout.trim(),
+                stderr: stderr.trim(),
+                success: code === 0
+            });
+        });
+
+        proc.on('error', (err) => {
+            resolve({
+                command,
+                error: err.message,
+                success: false
+            });
+        });
+
+        // Handle timeout
+        setTimeout(() => {
+            proc.kill();
+            resolve({
+                command,
+                error: 'Command timed out',
+                success: false
+            });
+        }, timeout);
+    });
+}

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

@@ -0,0 +1,140 @@
+// File tool definitions and implementations for Claude Predict
+
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+
+// Tool definitions for Claude API
+export const fileToolDefinitions = [
+    {
+        name: 'read_file',
+        description: 'Read contents of a file',
+        input_schema: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Path to the file to read'
+                }
+            },
+            required: ['path']
+        }
+    },
+    {
+        name: 'write_file',
+        description: 'Write content to a file',
+        input_schema: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Path to the file to write'
+                },
+                content: {
+                    type: 'string',
+                    description: 'Content to write to the file'
+                }
+            },
+            required: ['path', 'content']
+        }
+    },
+    {
+        name: 'list_files',
+        description: 'List files in a directory',
+        input_schema: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Directory path (default: current directory)'
+                },
+                pattern: {
+                    type: 'string',
+                    description: 'Optional glob pattern to filter files'
+                }
+            }
+        }
+    }
+];
+
+// Tool implementations
+export async function executeFileTool(name, input) {
+    switch (name) {
+        case 'read_file': {
+            const filePath = resolve(input.path);
+
+            if (!existsSync(filePath)) {
+                return { error: `File not found: ${input.path}` };
+            }
+
+            try {
+                const content = readFileSync(filePath, 'utf-8');
+                return {
+                    path: input.path,
+                    content,
+                    size: content.length,
+                    lines: content.split('\n').length
+                };
+            } catch (err) {
+                return { error: `Failed to read file: ${err.message}` };
+            }
+        }
+
+        case 'write_file': {
+            const filePath = resolve(input.path);
+
+            try {
+                writeFileSync(filePath, input.content, 'utf-8');
+                return {
+                    success: true,
+                    path: input.path,
+                    size: input.content.length,
+                    lines: input.content.split('\n').length
+                };
+            } catch (err) {
+                return { error: `Failed to write file: ${err.message}` };
+            }
+        }
+
+        case 'list_files': {
+            const { readdirSync, statSync } = await import('fs');
+            const dirPath = resolve(input.path || '.');
+
+            if (!existsSync(dirPath)) {
+                return { error: `Directory not found: ${input.path}` };
+            }
+
+            try {
+                const entries = readdirSync(dirPath);
+                const files = entries.map(entry => {
+                    const fullPath = resolve(dirPath, entry);
+                    const stat = statSync(fullPath);
+                    return {
+                        name: entry,
+                        type: stat.isDirectory() ? 'directory' : 'file',
+                        size: stat.isFile() ? stat.size : null
+                    };
+                });
+
+                // Filter by pattern if provided
+                let filtered = files;
+                if (input.pattern) {
+                    const regex = new RegExp(
+                        input.pattern.replace(/\*/g, '.*').replace(/\?/g, '.')
+                    );
+                    filtered = files.filter(f => regex.test(f.name));
+                }
+
+                return {
+                    path: input.path || '.',
+                    files: filtered,
+                    total: filtered.length
+                };
+            } catch (err) {
+                return { error: `Failed to list directory: ${err.message}` };
+            }
+        }
+
+        default:
+            return { error: `Unknown file tool: ${name}` };
+    }
+}