@optima-chat/bi-cli 0.2.0

package/src/commands/auth.ts

@@ -0,0 +1,277 @@
+import { Command } from 'commander';
+import axios from 'axios';
+import ora from 'ora';
+import chalk from 'chalk';
+import { setConfig, clearAuth, getConfig } from '../config/index.js';
+import { success, error, info } from '../utils/output.js';
+
+interface DeviceCodeResponse {
+  device_code: string;
+  user_code: string;
+  verification_uri: string;
+  verification_uri_complete?: string;
+  expires_in: number;
+  interval: number;
+}
+
+interface TokenResponse {
+  access_token: string;
+  refresh_token: string;
+  expires_in: number;
+  token_type: string;
+}
+
+interface UserInfo {
+  id: string;
+  email: string;
+  role: 'merchant' | 'admin';
+  merchant_id?: string;
+}
+
+export function createAuthCommand(): Command {
+  const auth = new Command('auth').description('Authentication commands');
+
+  // auth login
+  auth
+    .command('login')
+    .description('Login with OAuth 2.0 Device Flow')
+    .option('--env <environment>', 'Environment (production|stage|development)', 'production')
+    .action(async (options) => {
+      const { env } = options;
+
+      // Set URLs based on environment
+      const authUrls = {
+        production: 'https://auth.optima.chat',
+        stage: 'https://auth-stage.optima.chat',
+        development: 'http://localhost:4000',
+      };
+
+      const backendUrls = {
+        production: 'https://bi-api.optima.chat',
+        stage: 'https://bi-api-stage.optima.chat',
+        development: 'http://localhost:3001',
+      };
+
+      const authUrl = authUrls[env as keyof typeof authUrls];
+      const backendUrl = backendUrls[env as keyof typeof backendUrls];
+
+      if (!authUrl || !backendUrl) {
+        error(`Invalid environment: ${env}`);
+        process.exit(1);
+      }
+
+      setConfig('environment', env);
+      setConfig('authUrl', authUrl);
+      setConfig('backendUrl', backendUrl);
+
+      info(`Logging in to ${env} environment...`);
+
+      try {
+        // Step 1: Request device code
+        const spinner = ora('Requesting device code...').start();
+        const deviceCodeRes = await axios.post<DeviceCodeResponse>(
+          `${authUrl}/api/v1/oauth/device/authorize`,
+          { client_id: 'bi-cli-aqkutatj' }
+        );
+        spinner.succeed('Device code received');
+
+        const {
+          device_code,
+          user_code,
+          verification_uri,
+          verification_uri_complete,
+          expires_in,
+          interval,
+        } = deviceCodeRes.data;
+
+        // Use verification_uri_complete if available (includes code pre-filled)
+        const browserUrl = verification_uri_complete || verification_uri;
+
+        // Step 2: Display authorization instructions
+        console.log(chalk.bold('\n📋 Authorization Required:\n'));
+        if (verification_uri_complete) {
+          console.log(`  Opening browser with pre-filled code: ${chalk.yellow.bold(user_code)}`);
+          console.log(`  URL: ${chalk.cyan(verification_uri_complete)}\n`);
+        } else {
+          console.log(`  1. Visit: ${chalk.cyan(verification_uri)}`);
+          console.log(`  2. Enter code: ${chalk.yellow.bold(user_code)}\n`);
+        }
+
+        // Step 3: Open browser automatically
+        const { default: open } = await import('open');
+        await open(browserUrl);
+        info('Browser opened automatically');
+
+        // Step 4: Poll for token
+        const pollSpinner = ora('Waiting for authorization...').start();
+        const startTime = Date.now();
+        const expiresAt = startTime + expires_in * 1000;
+
+        let token: TokenResponse | null = null;
+        let pollCount = 0;
+
+        while (Date.now() < expiresAt) {
+          await new Promise((resolve) => setTimeout(resolve, interval * 1000));
+          pollCount++;
+
+          try {
+            const tokenRes = await axios.post<
+              TokenResponse | { error: string; error_description: string }
+            >(
+              `${authUrl}/api/v1/oauth/device/token`,
+              new URLSearchParams({
+                grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+                client_id: 'bi-cli-aqkutatj',
+                device_code,
+              }),
+              {
+                headers: {
+                  'Content-Type': 'application/x-www-form-urlencoded',
+                },
+              }
+            );
+
+            // Check if response contains an error (auth server returns 200 with error object)
+            if ('error' in tokenRes.data) {
+              const errorCode = tokenRes.data.error;
+              if (errorCode === 'authorization_pending') {
+                pollSpinner.text = `Waiting for authorization... (attempt ${pollCount})`;
+                continue;
+              } else if (errorCode === 'slow_down') {
+                pollSpinner.text = `Slowing down polling... (attempt ${pollCount})`;
+                await new Promise((resolve) => setTimeout(resolve, 5000));
+                continue;
+              } else {
+                pollSpinner.fail(`Polling failed: ${errorCode}`);
+                throw new Error(tokenRes.data.error_description);
+              }
+            }
+
+            token = tokenRes.data as TokenResponse;
+            pollSpinner.text = `Authorization successful after ${pollCount} attempts`;
+            break;
+          } catch (err: unknown) {
+            const error = err as { response?: { data?: { error?: string } } };
+            const errorCode = error.response?.data?.error;
+
+            if (errorCode === 'authorization_pending') {
+              // Continue polling
+              pollSpinner.text = `Waiting for authorization... (attempt ${pollCount})`;
+              continue;
+            } else if (errorCode === 'slow_down') {
+              // Increase interval
+              pollSpinner.text = `Slowing down polling... (attempt ${pollCount})`;
+              await new Promise((resolve) => setTimeout(resolve, 5000));
+              continue;
+            } else {
+              // Unexpected error
+              pollSpinner.fail(`Polling failed: ${errorCode || 'unknown error'}`);
+              throw err;
+            }
+          }
+        }
+
+        if (!token) {
+          pollSpinner.fail('Authorization timeout');
+          error('Please try again');
+          process.exit(1);
+        }
+
+        pollSpinner.succeed();
+
+        // Step 5: Save tokens
+        setConfig('accessToken', token.access_token);
+        setConfig('refreshToken', token.refresh_token);
+
+        // Step 6: Fetch user info (optional - just for display)
+        try {
+          const userInfo = await axios.get<UserInfo>(`${authUrl}/api/v1/users/me`, {
+            headers: { Authorization: `Bearer ${token.access_token}` },
+          });
+          success(`Logged in as ${chalk.bold(userInfo.data.email)} (${userInfo.data.role})`);
+        } catch (userInfoErr) {
+          // If fetching user info fails, still consider login successful
+          success('Login successful! Token saved.');
+        }
+      } catch (err: unknown) {
+        const errorMsg = err instanceof Error ? err.message : 'Unknown error';
+        error(`Login failed: ${errorMsg}`);
+        process.exit(1);
+      }
+    });
+
+  // auth logout
+  auth
+    .command('logout')
+    .description('Logout and clear stored credentials')
+    .action(() => {
+      clearAuth();
+      success('Logged out successfully');
+    });
+
+  // auth whoami
+  auth
+    .command('whoami')
+    .description('Show current user information')
+    .action(async () => {
+      const cfg = getConfig();
+
+      if (!cfg.accessToken) {
+        error('Not logged in. Run: bi-cli auth login');
+        process.exit(1);
+      }
+
+      try {
+        const userInfo = await axios.get<UserInfo>(`${cfg.authUrl}/api/v1/users/me`, {
+          headers: { Authorization: `Bearer ${cfg.accessToken}` },
+        });
+
+        console.log(chalk.bold('\n👤 Current User:\n'));
+        console.log(`  Email: ${chalk.cyan(userInfo.data.email)}`);
+        console.log(`  Role: ${chalk.yellow(userInfo.data.role)}`);
+        if (userInfo.data.merchant_id) {
+          console.log(`  Merchant ID: ${chalk.gray(userInfo.data.merchant_id)}`);
+        }
+        console.log(`  Environment: ${chalk.green(cfg.environment)}\n`);
+      } catch (err: unknown) {
+        const axiosError = err as { response?: { status?: number } };
+        if (axiosError.response?.status === 401) {
+          error('Token expired. Please login again: bi-cli auth login');
+        } else {
+          const errorMsg = err instanceof Error ? err.message : 'Unknown error';
+          error(`Failed to fetch user info: ${errorMsg}`);
+        }
+        process.exit(1);
+      }
+    });
+
+  // auth switch
+  auth
+    .command('switch')
+    .description('Switch environment')
+    .option('--env <environment>', 'Environment (production|stage|development)', 'production')
+    .action((options) => {
+      const { env } = options;
+
+      const backendUrls = {
+        production: 'https://bi-api.optima.chat',
+        stage: 'https://bi-api-stage.optima.chat',
+        development: 'http://localhost:3001',
+      };
+
+      const backendUrl = backendUrls[env as keyof typeof backendUrls];
+      if (!backendUrl) {
+        error(`Invalid environment: ${env}`);
+        process.exit(1);
+      }
+
+      setConfig('environment', env);
+      setConfig('backendUrl', backendUrl);
+      clearAuth(); // Clear tokens when switching environment
+
+      success(`Switched to ${env} environment`);
+      info('Please login again: bi-cli auth login');
+    });
+
+  return auth;
+}

package/src/commands/product.ts

@@ -0,0 +1,327 @@
+import { Command } from 'commander';
+import axios from 'axios';
+import { getConfig } from '../config/index.js';
+import { outputJson, outputPretty, error, OutputFormat, info } from '../utils/output.js';
+
+interface BestSellersResponse {
+  success: boolean;
+  data: {
+    merchant_id: string;
+    sort_by: string;
+    products: Array<{
+      rank: number;
+      title: string;
+      revenue: number;
+      units_sold: number;
+      orders: number;
+      avg_price: number;
+      revenue_share: number;
+    }>;
+    total_revenue: number;
+  };
+}
+
+interface ABCAnalysisResponse {
+  success: boolean;
+  data: {
+    merchant_id: string;
+    total_revenue: number;
+    summary: {
+      A: { description: string; count: number; revenue: number; percent_of_products: number };
+      B: { description: string; count: number; revenue: number; percent_of_products: number };
+      C: { description: string; count: number; revenue: number; percent_of_products: number };
+    };
+    products: Array<{
+      title: string;
+      revenue: number;
+      units: number;
+      revenue_percent: number;
+      cumulative_percent: number;
+      category: 'A' | 'B' | 'C';
+    }>;
+  };
+}
+
+interface PriceAnalysisResponse {
+  success: boolean;
+  data: {
+    merchant_id: string;
+    price_ranges: Array<{
+      range: string;
+      products: number;
+      revenue: number;
+      units: number;
+      avg_price: number;
+      revenue_share: number;
+      units_share: number;
+    }>;
+    totals: {
+      revenue: number;
+      units: number;
+    };
+  };
+}
+
+interface PerformanceResponse {
+  success: boolean;
+  data: {
+    merchant_id: string;
+    period: { days: number };
+    products: Array<{
+      title: string;
+      price: number;
+      cost: number | null;
+      inventory: number;
+      status: string;
+      sales: {
+        units: number;
+        revenue: number;
+        orders: number;
+      };
+      metrics: {
+        margin_percent: number;
+        days_of_stock: number;
+        velocity: number;
+      };
+    }>;
+  };
+}
+
+export function createProductCommand(): Command {
+  const product = new Command('product').description('Product analytics');
+
+  // product best-sellers
+  product
+    .command('best-sellers')
+    .description('Get best selling products')
+    .option('--limit <number>', 'Number of products to return', '10')
+    .option('--sort <field>', 'Sort by: revenue, quantity, orders', 'revenue')
+    .option('--pretty', 'Output in pretty table format')
+    .action(async (options) => {
+      const cfg = getConfig();
+      if (!cfg.accessToken) {
+        error('Not logged in. Run: bi-cli auth login');
+        process.exit(1);
+      }
+
+      const format = options.pretty ? OutputFormat.PRETTY : OutputFormat.JSON;
+
+      try {
+        const response = await axios.get<BestSellersResponse>(
+          `${cfg.backendUrl}/api/v1/products/best-sellers`,
+          {
+            params: { limit: options.limit, sort_by: options.sort },
+            headers: { Authorization: `Bearer ${cfg.accessToken}` },
+          }
+        );
+
+        if (!response.data.success) {
+          error('Failed to fetch best sellers');
+          process.exit(1);
+        }
+
+        const { products, total_revenue } = response.data.data;
+
+        if (format === OutputFormat.JSON) {
+          outputJson(response.data.data);
+        } else {
+          console.log('\n🏆 Best Selling Products\n');
+          outputPretty(
+            products.map((p) => ({
+              Rank: p.rank,
+              Title: p.title.length > 30 ? p.title.slice(0, 27) + '...' : p.title,
+              Revenue: `¥${p.revenue.toFixed(2)}`,
+              Units: p.units_sold,
+              Orders: p.orders,
+              Share: `${p.revenue_share.toFixed(1)}%`,
+            })),
+            ['Rank', 'Title', 'Revenue', 'Units', 'Orders', 'Share']
+          );
+          info(`Total Revenue: ¥${total_revenue.toFixed(2)}`);
+        }
+      } catch (err: unknown) {
+        handleApiError(err);
+      }
+    });
+
+  // product abc-analysis
+  product
+    .command('abc-analysis')
+    .description('ABC inventory analysis')
+    .option('--pretty', 'Output in pretty table format')
+    .action(async (options) => {
+      const cfg = getConfig();
+      if (!cfg.accessToken) {
+        error('Not logged in. Run: bi-cli auth login');
+        process.exit(1);
+      }
+
+      const format = options.pretty ? OutputFormat.PRETTY : OutputFormat.JSON;
+
+      try {
+        const response = await axios.get<ABCAnalysisResponse>(
+          `${cfg.backendUrl}/api/v1/products/abc-analysis`,
+          {
+            headers: { Authorization: `Bearer ${cfg.accessToken}` },
+          }
+        );
+
+        if (!response.data.success) {
+          error('Failed to fetch ABC analysis');
+          process.exit(1);
+        }
+
+        const { summary, products, total_revenue } = response.data.data;
+
+        if (format === OutputFormat.JSON) {
+          outputJson(response.data.data);
+        } else {
+          console.log('\n📊 ABC Analysis Summary\n');
+          outputPretty({
+            'Category A (High Value)': `${summary.A.count} products (${summary.A.percent_of_products.toFixed(1)}%) - ¥${summary.A.revenue.toFixed(2)}`,
+            'Category B (Medium Value)': `${summary.B.count} products (${summary.B.percent_of_products.toFixed(1)}%) - ¥${summary.B.revenue.toFixed(2)}`,
+            'Category C (Low Value)': `${summary.C.count} products (${summary.C.percent_of_products.toFixed(1)}%) - ¥${summary.C.revenue.toFixed(2)}`,
+            'Total Revenue': `¥${total_revenue.toFixed(2)}`,
+          });
+
+          console.log('\n📦 Top Products by Category\n');
+          const topProducts = products.slice(0, 15);
+          outputPretty(
+            topProducts.map((p) => ({
+              Category: p.category,
+              Title: p.title.length > 25 ? p.title.slice(0, 22) + '...' : p.title,
+              Revenue: `¥${p.revenue.toFixed(2)}`,
+              Units: p.units,
+              'Revenue %': `${p.revenue_percent.toFixed(1)}%`,
+            })),
+            ['Category', 'Title', 'Revenue', 'Units', 'Revenue %']
+          );
+        }
+      } catch (err: unknown) {
+        handleApiError(err);
+      }
+    });
+
+  // product price-analysis
+  product
+    .command('price-analysis')
+    .description('Price point analysis')
+    .option('--pretty', 'Output in pretty table format')
+    .action(async (options) => {
+      const cfg = getConfig();
+      if (!cfg.accessToken) {
+        error('Not logged in. Run: bi-cli auth login');
+        process.exit(1);
+      }
+
+      const format = options.pretty ? OutputFormat.PRETTY : OutputFormat.JSON;
+
+      try {
+        const response = await axios.get<PriceAnalysisResponse>(
+          `${cfg.backendUrl}/api/v1/products/price-analysis`,
+          {
+            headers: { Authorization: `Bearer ${cfg.accessToken}` },
+          }
+        );
+
+        if (!response.data.success) {
+          error('Failed to fetch price analysis');
+          process.exit(1);
+        }
+
+        const { price_ranges, totals } = response.data.data;
+
+        if (format === OutputFormat.JSON) {
+          outputJson(response.data.data);
+        } else {
+          console.log('\n💰 Price Distribution Analysis\n');
+          outputPretty(
+            price_ranges.map((r) => ({
+              Range: r.range,
+              Products: r.products,
+              Revenue: `¥${r.revenue.toFixed(2)}`,
+              Units: r.units,
+              'Avg Price': `¥${r.avg_price.toFixed(2)}`,
+              'Revenue Share': `${r.revenue_share.toFixed(1)}%`,
+            })),
+            ['Range', 'Products', 'Revenue', 'Units', 'Avg Price', 'Revenue Share']
+          );
+          info(`Total Revenue: ¥${totals.revenue.toFixed(2)} | Total Units: ${totals.units}`);
+        }
+      } catch (err: unknown) {
+        handleApiError(err);
+      }
+    });
+
+  // product performance
+  product
+    .command('performance')
+    .description('Get product performance metrics')
+    .option('--days <number>', 'Number of days', '30')
+    .option('--limit <number>', 'Number of products', '20')
+    .option('--pretty', 'Output in pretty table format')
+    .action(async (options) => {
+      const cfg = getConfig();
+      if (!cfg.accessToken) {
+        error('Not logged in. Run: bi-cli auth login');
+        process.exit(1);
+      }
+
+      const format = options.pretty ? OutputFormat.PRETTY : OutputFormat.JSON;
+
+      try {
+        const response = await axios.get<PerformanceResponse>(
+          `${cfg.backendUrl}/api/v1/products/performance`,
+          {
+            params: { days: options.days, limit: options.limit },
+            headers: { Authorization: `Bearer ${cfg.accessToken}` },
+          }
+        );
+
+        if (!response.data.success) {
+          error('Failed to fetch product performance');
+          process.exit(1);
+        }
+
+        const { products, period } = response.data.data;
+
+        if (format === OutputFormat.JSON) {
+          outputJson(response.data.data);
+        } else {
+          console.log(`\n📈 Product Performance (Last ${period.days} days)\n`);
+          outputPretty(
+            products.map((p) => ({
+              Title: p.title.length > 20 ? p.title.slice(0, 17) + '...' : p.title,
+              Price: `¥${p.price.toFixed(2)}`,
+              Revenue: `¥${p.sales.revenue.toFixed(2)}`,
+              Units: p.sales.units,
+              Stock: p.inventory,
+              'Days Stock': p.metrics.days_of_stock.toFixed(0),
+              'Margin %': `${p.metrics.margin_percent.toFixed(1)}%`,
+            })),
+            ['Title', 'Price', 'Revenue', 'Units', 'Stock', 'Days Stock', 'Margin %']
+          );
+        }
+      } catch (err: unknown) {
+        handleApiError(err);
+      }
+    });
+
+  return product;
+}
+
+function handleApiError(err: unknown): never {
+  const axiosError = err as {
+    response?: { status?: number; data?: { error?: { message?: string } } };
+  };
+  const errorObj = err as Error;
+
+  if (axiosError.response?.status === 401) {
+    error('Authentication failed. Please login again: bi-cli auth login');
+  } else if (axiosError.response?.data?.error) {
+    error(`Error: ${axiosError.response.data.error.message}`);
+  } else {
+    error(`Request failed: ${errorObj.message || 'Unknown error'}`);
+  }
+  process.exit(1);
+}