@paylobster/cli 4.0.1 → 4.1.0

package/src/commands/credit-score.ts

@@ -0,0 +1,193 @@
+import { Command } from 'commander';
+import { success, error, info, warning, withSpinner, outputJSON, formatAddress, printReputation, createTable } from '../lib/display';
+import { getWalletAddress } from '../lib/wallet';
+import type { OutputOptions } from '../lib/types';
+import chalk from 'chalk';
+
+export function createCreditScoreCommand(): Command {
+  const cmd = new Command('credit-score')
+    .description('Check credit scores and manage credit lines')
+    .argument('[address]', 'Address to check (optional, defaults to your address)')
+    .option('--json', 'Output as JSON')
+    .action(async (address: string | undefined, options: OutputOptions) => {
+      try {
+        const targetAddress = address || getWalletAddress();
+
+        if (address && (!address.startsWith('0x') || address.length !== 42)) {
+          error('Invalid address format');
+          process.exit(1);
+        }
+
+        // Placeholder data
+        const creditData = {
+          address: targetAddress,
+          score: 750,
+          creditLine: '5000 USDC',
+          availableCredit: '3500 USDC',
+          usedCredit: '1500 USDC',
+          paymentHistory: 'Excellent',
+          onTimePayments: 45,
+          latePayments: 2,
+          totalTransactions: 47,
+        };
+
+        if (outputJSON(creditData, options)) {
+          return;
+        }
+
+        console.log();
+        console.log(chalk.bold.cyan('🦞 Credit Score Report'));
+        console.log(chalk.gray('─'.repeat(50)));
+        console.log('Address:          ', formatAddress(creditData.address));
+        console.log('Credit Score:     ', printReputation(creditData.score / 10)); // Convert to 0-100 scale
+        console.log();
+        console.log(chalk.bold('Credit Line'));
+        console.log('  Total:          ', creditData.creditLine);
+        console.log('  Available:      ', chalk.green(creditData.availableCredit));
+        console.log('  Used:           ', chalk.yellow(creditData.usedCredit));
+        console.log();
+        console.log(chalk.bold('Payment History'));
+        console.log('  On-time:        ', chalk.green(creditData.onTimePayments));
+        console.log('  Late:           ', chalk.red(creditData.latePayments));
+        console.log('  Total:          ', creditData.totalTransactions);
+        console.log('  Rating:         ', chalk.green(creditData.paymentHistory));
+        console.log();
+      } catch (err) {
+        error(`Failed to get credit score: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob credit-score request
+  cmd
+    .command('request')
+    .description('Request a credit line')
+    .requiredOption('--amount <amount>', 'Credit line amount in USDC')
+    .option('--json', 'Output as JSON')
+    .action(async (options: { amount: string } & OutputOptions) => {
+      try {
+        const amount = parseFloat(options.amount);
+        if (isNaN(amount) || amount <= 0) {
+          error('Invalid amount. Must be a positive number');
+          process.exit(1);
+        }
+
+        info(`Requesting credit line: ${options.amount} USDC`);
+
+        const requestId = Math.floor(Math.random() * 1000000);
+
+        const txHash = await withSpinner(
+          'Submitting credit line request...',
+          async () => {
+            // Placeholder - implement actual contract call
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            return '0x' + Math.random().toString(16).substring(2, 66);
+          }
+        );
+
+        if (outputJSON({
+          requestId,
+          amount: options.amount,
+          txHash,
+        }, options)) {
+          return;
+        }
+
+        success('Credit line request submitted!');
+        info(`Request ID: ${requestId}`);
+        info(`Amount: ${options.amount} USDC`);
+        info(`Transaction: ${txHash}`);
+        console.log();
+        warning('Credit requests are subject to approval based on your credit score.');
+      } catch (err) {
+        error(`Failed to request credit line: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob credit-score draw
+  cmd
+    .command('draw')
+    .description('Draw from credit line')
+    .argument('<creditLineId>', 'Credit line ID')
+    .requiredOption('--amount <amount>', 'Amount to draw in USDC')
+    .option('--json', 'Output as JSON')
+    .action(async (creditLineId: string, options: { amount: string } & OutputOptions) => {
+      try {
+        const amount = parseFloat(options.amount);
+        if (isNaN(amount) || amount <= 0) {
+          error('Invalid amount. Must be a positive number');
+          process.exit(1);
+        }
+
+        const txHash = await withSpinner(
+          `Drawing ${options.amount} USDC from credit line...`,
+          async () => {
+            // Placeholder - implement actual contract call
+            await new Promise(resolve => setTimeout(resolve, 1500));
+            return '0x' + Math.random().toString(16).substring(2, 66);
+          }
+        );
+
+        if (outputJSON({
+          creditLineId,
+          amount: options.amount,
+          txHash,
+        }, options)) {
+          return;
+        }
+
+        success('Credit drawn successfully!');
+        info(`Credit Line ID: ${creditLineId}`);
+        info(`Amount: ${options.amount} USDC`);
+        info(`Transaction: ${txHash}`);
+      } catch (err) {
+        error(`Failed to draw credit: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob credit-score repay
+  cmd
+    .command('repay')
+    .description('Repay credit line')
+    .argument('<creditLineId>', 'Credit line ID')
+    .requiredOption('--amount <amount>', 'Amount to repay in USDC')
+    .option('--json', 'Output as JSON')
+    .action(async (creditLineId: string, options: { amount: string } & OutputOptions) => {
+      try {
+        const amount = parseFloat(options.amount);
+        if (isNaN(amount) || amount <= 0) {
+          error('Invalid amount. Must be a positive number');
+          process.exit(1);
+        }
+
+        const txHash = await withSpinner(
+          `Repaying ${options.amount} USDC to credit line...`,
+          async () => {
+            // Placeholder - implement actual contract call
+            await new Promise(resolve => setTimeout(resolve, 1500));
+            return '0x' + Math.random().toString(16).substring(2, 66);
+          }
+        );
+
+        if (outputJSON({
+          creditLineId,
+          amount: options.amount,
+          txHash,
+        }, options)) {
+          return;
+        }
+
+        success('Repayment successful!');
+        info(`Credit Line ID: ${creditLineId}`);
+        info(`Amount: ${options.amount} USDC`);
+        info(`Transaction: ${txHash}`);
+      } catch (err) {
+        error(`Failed to repay credit: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}

package/src/commands/dispute.ts

@@ -0,0 +1,274 @@
+import { Command } from 'commander';
+import { success, error, info, warning, withSpinner, outputJSON, formatAddress, confirm, createTable, formatStatus } from '../lib/display';
+import type { OutputOptions } from '../lib/types';
+import fs from 'fs/promises';
+import path from 'path';
+
+export function createDisputeCommand(): Command {
+  const cmd = new Command('dispute')
+    .description('Manage escrow disputes');
+
+  // plob dispute open
+  cmd
+    .command('open')
+    .description('Open a dispute for an escrow')
+    .requiredOption('--escrow <id>', 'Escrow ID')
+    .requiredOption('--reason <reason>', 'Dispute reason')
+    .option('--evidence <file>', 'Evidence file path')
+    .option('--json', 'Output as JSON')
+    .action(async (options: {
+      escrow: string;
+      reason: string;
+      evidence?: string;
+    } & OutputOptions) => {
+      try {
+        let evidenceHash = null;
+
+        // Handle evidence file if provided
+        if (options.evidence) {
+          const evidencePath = path.resolve(options.evidence);
+          try {
+            const evidenceData = await fs.readFile(evidencePath);
+            info(`Evidence file loaded: ${path.basename(evidencePath)} (${evidenceData.length} bytes)`);
+            
+            // Placeholder: Upload to IPFS or similar
+            evidenceHash = '0x' + Math.random().toString(16).substring(2, 66);
+            info(`Evidence uploaded: ${evidenceHash}`);
+          } catch (err) {
+            error(`Failed to read evidence file: ${err}`);
+            process.exit(1);
+          }
+        }
+
+        const disputeId = Math.floor(Math.random() * 1000000);
+
+        const txHash = await withSpinner(
+          'Opening dispute...',
+          async () => {
+            // Placeholder - implement actual contract call
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            return '0x' + Math.random().toString(16).substring(2, 66);
+          }
+        );
+
+        if (outputJSON({
+          disputeId,
+          escrowId: options.escrow,
+          reason: options.reason,
+          evidenceHash,
+          txHash,
+        }, options)) {
+          return;
+        }
+
+        success('Dispute opened!');
+        info(`Dispute ID: ${disputeId}`);
+        info(`Escrow ID: ${options.escrow}`);
+        info(`Reason: ${options.reason}`);
+        if (evidenceHash) {
+          info(`Evidence: ${evidenceHash}`);
+        }
+        info(`Transaction: ${txHash}`);
+      } catch (err) {
+        error(`Failed to open dispute: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob dispute submit
+  cmd
+    .command('submit')
+    .description('Submit additional evidence for a dispute')
+    .argument('<disputeId>', 'Dispute ID')
+    .requiredOption('--evidence <file>', 'Evidence file path')
+    .option('--json', 'Output as JSON')
+    .action(async (disputeId: string, options: { evidence: string } & OutputOptions) => {
+      try {
+        const evidencePath = path.resolve(options.evidence);
+        const evidenceData = await fs.readFile(evidencePath);
+        
+        info(`Submitting evidence: ${path.basename(evidencePath)} (${evidenceData.length} bytes)`);
+
+        const evidenceHash = '0x' + Math.random().toString(16).substring(2, 66);
+
+        const txHash = await withSpinner(
+          'Submitting evidence...',
+          async () => {
+            // Placeholder - implement actual contract call
+            await new Promise(resolve => setTimeout(resolve, 1500));
+            return '0x' + Math.random().toString(16).substring(2, 66);
+          }
+        );
+
+        if (outputJSON({
+          disputeId,
+          evidenceHash,
+          txHash,
+        }, options)) {
+          return;
+        }
+
+        success('Evidence submitted!');
+        info(`Dispute ID: ${disputeId}`);
+        info(`Evidence: ${evidenceHash}`);
+        info(`Transaction: ${txHash}`);
+      } catch (err) {
+        error(`Failed to submit evidence: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob dispute get
+  cmd
+    .command('get')
+    .description('Get dispute details')
+    .argument('<disputeId>', 'Dispute ID')
+    .option('--json', 'Output as JSON')
+    .action(async (disputeId: string, options: OutputOptions) => {
+      try {
+        // Placeholder data
+        const dispute = {
+          id: disputeId,
+          escrowId: '123',
+          plaintiff: '0x1234567890123456789012345678901234567890',
+          defendant: '0x0987654321098765432109876543210987654321',
+          reason: 'Service not delivered as agreed',
+          status: 'pending',
+          evidence: [
+            '0xabcd1234...',
+            '0xef567890...',
+          ],
+          createdAt: new Date().toISOString(),
+        };
+
+        if (outputJSON(dispute, options)) {
+          return;
+        }
+
+        console.log();
+        console.log('Dispute ID:    ', dispute.id);
+        console.log('Escrow ID:     ', dispute.escrowId);
+        console.log('Plaintiff:     ', dispute.plaintiff);
+        console.log('Defendant:     ', dispute.defendant);
+        console.log('Reason:        ', dispute.reason);
+        console.log('Status:        ', formatStatus(dispute.status));
+        console.log('Evidence:      ', dispute.evidence.length, 'file(s)');
+        console.log('Created:       ', dispute.createdAt);
+        console.log();
+      } catch (err) {
+        error(`Failed to get dispute: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob dispute settle
+  cmd
+    .command('settle')
+    .description('Settle a dispute')
+    .argument('<disputeId>', 'Dispute ID')
+    .requiredOption('--terms <terms>', 'Settlement terms')
+    .option('--yes', 'Skip confirmation')
+    .option('--json', 'Output as JSON')
+    .action(async (disputeId: string, options: {
+      terms: string;
+      yes?: boolean;
+    } & OutputOptions) => {
+      try {
+        if (!options.yes) {
+          console.log();
+          console.log('Settlement terms:', options.terms);
+          console.log();
+
+          const confirmed = await confirm(`Settle dispute ${disputeId}?`);
+          if (!confirmed) {
+            info('Cancelled');
+            process.exit(0);
+          }
+        }
+
+        const txHash = await withSpinner(
+          'Settling dispute...',
+          async () => {
+            // Placeholder - implement actual contract call
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            return '0x' + Math.random().toString(16).substring(2, 66);
+          }
+        );
+
+        if (outputJSON({
+          disputeId,
+          terms: options.terms,
+          txHash,
+        }, options)) {
+          return;
+        }
+
+        success('Dispute settled!');
+        info(`Dispute ID: ${disputeId}`);
+        info(`Terms: ${options.terms}`);
+        info(`Transaction: ${txHash}`);
+      } catch (err) {
+        error(`Failed to settle dispute: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  // plob dispute list
+  cmd
+    .command('list')
+    .description('List disputes')
+    .option('--json', 'Output as JSON')
+    .action(async (options: OutputOptions) => {
+      try {
+        // Placeholder data
+        const disputes = [
+          {
+            id: 1,
+            escrowId: 123,
+            plaintiff: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
+            defendant: '0x8626f6940E2eb28930eFb4CeF49B2d1F2C9C1199',
+            reason: 'Service not delivered',
+            status: 'pending',
+          },
+          {
+            id: 2,
+            escrowId: 456,
+            plaintiff: '0x1234567890123456789012345678901234567890',
+            defendant: '0x0987654321098765432109876543210987654321',
+            reason: 'Quality issues',
+            status: 'settled',
+          },
+        ];
+
+        if (outputJSON(disputes, options)) {
+          return;
+        }
+
+        if (disputes.length === 0) {
+          info('No disputes found');
+          return;
+        }
+
+        const table = createTable({
+          head: ['ID', 'Escrow', 'Plaintiff', 'Defendant', 'Status'],
+        });
+
+        for (const dispute of disputes) {
+          table.push([
+            dispute.id,
+            dispute.escrowId,
+            formatAddress(dispute.plaintiff),
+            formatAddress(dispute.defendant),
+            formatStatus(dispute.status),
+          ]);
+        }
+
+        console.log(table.toString());
+      } catch (err) {
+        error(`Failed to list disputes: ${err}`);
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}