@optima-chat/bi-cli 0.2.0

package/src/commands/sales.ts

@@ -0,0 +1,125 @@
+import { Command } from 'commander';
+import axios from 'axios';
+import { getConfig } from '../config/index.js';
+import { outputJson, outputPretty, error, OutputFormat } from '../utils/output.js';
+
+interface SalesSummary {
+  total_revenue: number;
+  total_orders: number;
+  avg_order_value: number;
+  unique_customers: number;
+}
+
+interface DailySales {
+  merchant_id: string;
+  date: string;
+  total_revenue: number;
+  order_count: number;
+  avg_order_value: number;
+  unique_customers: number;
+}
+
+interface SalesResponse {
+  success: boolean;
+  data: {
+    summary: SalesSummary;
+    daily: DailySales[];
+  };
+  meta: {
+    cached: boolean;
+    days: number;
+    query_time_ms?: number;
+  };
+}
+
+export function createSalesCommand(): Command {
+  const sales = new Command('sales').description('Sales analytics');
+
+  // sales get
+  sales
+    .command('get')
+    .description('Get sales data')
+    .option('--days <number>', 'Number of days to fetch', '7')
+    .option('--pretty', 'Output in pretty table format (default: JSON)')
+    .action(async (options) => {
+      const cfg = getConfig();
+
+      if (!cfg.accessToken) {
+        error('Not logged in. Run: bi-cli auth login');
+        process.exit(1);
+      }
+
+      const days = parseInt(options.days, 10);
+      if (isNaN(days) || days < 1 || days > 365) {
+        error('Days must be a number between 1 and 365');
+        process.exit(1);
+      }
+
+      const format = options.pretty ? OutputFormat.PRETTY : OutputFormat.JSON;
+
+      try {
+        const response = await axios.get<SalesResponse>(`${cfg.backendUrl}/api/v1/sales`, {
+          params: { days },
+          headers: {
+            Authorization: `Bearer ${cfg.accessToken}`,
+          },
+        });
+
+        if (!response.data.success) {
+          error('Failed to fetch sales data');
+          process.exit(1);
+        }
+
+        const { summary, daily } = response.data.data;
+
+        if (format === OutputFormat.JSON) {
+          outputJson(response.data.data);
+        } else {
+          // Pretty format with tables
+          console.log('\n📊 Sales Summary\n');
+          outputPretty({
+            'Total Revenue': `¥${summary.total_revenue.toFixed(2)}`,
+            'Total Orders': summary.total_orders,
+            'Average Order Value': `¥${summary.avg_order_value.toFixed(2)}`,
+            'Unique Customers': summary.unique_customers,
+          });
+
+          if (daily.length > 0) {
+            console.log('\n📅 Daily Breakdown\n');
+            outputPretty(
+              daily.map((d) => ({
+                Date: d.date,
+                Revenue: `¥${Number(d.total_revenue).toFixed(2)}`,
+                Orders: d.order_count,
+                AOV: `¥${Number(d.avg_order_value).toFixed(2)}`,
+                Customers: d.unique_customers,
+              })),
+              ['Date', 'Revenue', 'Orders', 'AOV', 'Customers']
+            );
+          }
+
+          // Show metadata
+          if (response.data.meta.cached) {
+            console.log('ℹ️  Data from cache');
+          } else if (response.data.meta.query_time_ms) {
+            console.log(`⏱️  Query time: ${response.data.meta.query_time_ms}ms`);
+          }
+        }
+      } catch (err: unknown) {
+        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(`Failed to fetch sales data: ${errorObj.message || 'Unknown error'}`);
+        }
+        process.exit(1);
+      }
+    });
+
+  return sales;
+}

package/src/commands/trends.ts

@@ -0,0 +1,355 @@
+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 RevenueTrendResponse {
+  success: boolean;
+  data: {
+    merchant_id: string;
+    period: { days: number; granularity: string };
+    statistics: {
+      total_revenue: number;
+      avg_revenue: number;
+      trend_direction: string;
+      data_points: number;
+    };
+    trend: Array<{
+      period: string;
+      revenue: number;
+      orders: number;
+      moving_avg_7: number | null;
+    }>;
+  };
+}
+
+interface HeatmapResponse {
+  success: boolean;
+  data: {
+    merchant_id: string;
+    period: { days: number };
+    heatmap: Array<{
+      day: string;
+      day_index: number;
+      hours: Array<{ hour: number; orders: number; revenue: number }>;
+    }>;
+    peak_times: Array<{ day: string; hour: string; orders: number }>;
+  };
+}
+
+interface SeasonalityResponse {
+  success: boolean;
+  data: {
+    merchant_id: string;
+    monthly_pattern: Array<{
+      month: number;
+      month_name: string;
+      revenue: number;
+      orders: number;
+      avg_order_value: number;
+      index: number;
+    }>;
+    insights: {
+      peak_months: string[];
+      low_months: string[];
+      avg_monthly_revenue: number;
+    };
+  };
+}
+
+interface ForecastResponse {
+  success: boolean;
+  data: {
+    merchant_id: string;
+    model: string;
+    baseline_days: number;
+    trend: {
+      direction: string;
+      daily_change: number;
+    };
+    forecast: Array<{
+      date: string;
+      day_of_week: string;
+      predicted_revenue: number;
+      confidence: string;
+    }>;
+    disclaimer: string;
+  };
+}
+
+export function createTrendsCommand(): Command {
+  const trends = new Command('trends').description('Trend analytics');
+
+  // trends revenue
+  trends
+    .command('revenue')
+    .description('Get revenue trend over time')
+    .option('--days <number>', 'Number of days', '30')
+    .option('--granularity <type>', 'Granularity: hourly, daily, weekly', 'daily')
+    .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<RevenueTrendResponse>(
+          `${cfg.backendUrl}/api/v1/trends/revenue`,
+          {
+            params: { days: options.days, granularity: options.granularity },
+            headers: { Authorization: `Bearer ${cfg.accessToken}` },
+          }
+        );
+
+        if (!response.data.success) {
+          error('Failed to fetch revenue trend');
+          process.exit(1);
+        }
+
+        const { statistics, trend, period } = response.data.data;
+
+        if (format === OutputFormat.JSON) {
+          outputJson(response.data.data);
+        } else {
+          console.log(`\n📈 Revenue Trend (Last ${period.days} days, ${period.granularity})\n`);
+
+          // Statistics
+          const trendIcon =
+            statistics.trend_direction === 'up'
+              ? '↑'
+              : statistics.trend_direction === 'down'
+                ? '↓'
+                : '→';
+          outputPretty({
+            'Total Revenue': `¥${statistics.total_revenue.toFixed(2)}`,
+            'Average Revenue': `¥${statistics.avg_revenue.toFixed(2)}`,
+            'Trend Direction': `${trendIcon} ${statistics.trend_direction}`,
+            'Data Points': statistics.data_points,
+          });
+
+          // Recent data points
+          console.log('\n📅 Recent Data\n');
+          const recentTrend = trend.slice(-10);
+          outputPretty(
+            recentTrend.map((t) => ({
+              Period: t.period.split('T')[0],
+              Revenue: `¥${t.revenue.toFixed(2)}`,
+              Orders: t.orders,
+              'MA(7)': t.moving_avg_7 ? `¥${t.moving_avg_7.toFixed(2)}` : '-',
+            })),
+            ['Period', 'Revenue', 'Orders', 'MA(7)']
+          );
+        }
+      } catch (err: unknown) {
+        handleApiError(err);
+      }
+    });
+
+  // trends heatmap
+  trends
+    .command('heatmap')
+    .description('Orders heatmap by day and hour')
+    .option('--days <number>', 'Number of days', '30')
+    .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<HeatmapResponse>(
+          `${cfg.backendUrl}/api/v1/trends/orders-heatmap`,
+          {
+            params: { days: options.days },
+            headers: { Authorization: `Bearer ${cfg.accessToken}` },
+          }
+        );
+
+        if (!response.data.success) {
+          error('Failed to fetch heatmap data');
+          process.exit(1);
+        }
+
+        const { peak_times, heatmap } = response.data.data;
+
+        if (format === OutputFormat.JSON) {
+          outputJson(response.data.data);
+        } else {
+          console.log('\n🔥 Peak Order Times\n');
+          outputPretty(
+            peak_times.map((p, i) => ({
+              Rank: i + 1,
+              Day: p.day,
+              Hour: p.hour,
+              Orders: p.orders,
+            })),
+            ['Rank', 'Day', 'Hour', 'Orders']
+          );
+
+          console.log('\n📊 Daily Summary\n');
+          outputPretty(
+            heatmap.map((d) => {
+              const totalOrders = d.hours.reduce((sum, h) => sum + h.orders, 0);
+              const totalRevenue = d.hours.reduce((sum, h) => sum + h.revenue, 0);
+              const peakHour = d.hours.reduce(
+                (max, h) => (h.orders > max.orders ? h : max),
+                d.hours[0]
+              );
+              return {
+                Day: d.day,
+                'Total Orders': totalOrders,
+                'Total Revenue': `¥${totalRevenue.toFixed(2)}`,
+                'Peak Hour': `${peakHour.hour}:00`,
+              };
+            }),
+            ['Day', 'Total Orders', 'Total Revenue', 'Peak Hour']
+          );
+        }
+      } catch (err: unknown) {
+        handleApiError(err);
+      }
+    });
+
+  // trends seasonality
+  trends
+    .command('seasonality')
+    .description('Monthly/seasonal patterns')
+    .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<SeasonalityResponse>(
+          `${cfg.backendUrl}/api/v1/trends/seasonality`,
+          {
+            headers: { Authorization: `Bearer ${cfg.accessToken}` },
+          }
+        );
+
+        if (!response.data.success) {
+          error('Failed to fetch seasonality data');
+          process.exit(1);
+        }
+
+        const { monthly_pattern, insights } = response.data.data;
+
+        if (format === OutputFormat.JSON) {
+          outputJson(response.data.data);
+        } else {
+          console.log('\n📅 Monthly Performance Pattern\n');
+          outputPretty(
+            monthly_pattern.map((m) => ({
+              Month: m.month_name.slice(0, 3),
+              Revenue: `¥${m.revenue.toFixed(2)}`,
+              Orders: m.orders,
+              'Avg Order': `¥${m.avg_order_value.toFixed(2)}`,
+              Index: `${m.index.toFixed(0)}%`,
+            })),
+            ['Month', 'Revenue', 'Orders', 'Avg Order', 'Index']
+          );
+
+          console.log('\n💡 Insights\n');
+          outputPretty({
+            'Peak Months': insights.peak_months.join(', ') || 'N/A',
+            'Low Months': insights.low_months.join(', ') || 'N/A',
+            'Avg Monthly Revenue': `¥${insights.avg_monthly_revenue.toFixed(2)}`,
+          });
+        }
+      } catch (err: unknown) {
+        handleApiError(err);
+      }
+    });
+
+  // trends forecast
+  trends
+    .command('forecast')
+    .description('Revenue forecast')
+    .option('--days <number>', 'Number of days to forecast', '7')
+    .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<ForecastResponse>(
+          `${cfg.backendUrl}/api/v1/trends/forecast`,
+          {
+            params: { forecast_days: options.days },
+            headers: { Authorization: `Bearer ${cfg.accessToken}` },
+          }
+        );
+
+        if (!response.data.success) {
+          error('Failed to generate forecast');
+          process.exit(1);
+        }
+
+        const { trend, forecast, baseline_days, disclaimer } = response.data.data;
+
+        if (format === OutputFormat.JSON) {
+          outputJson(response.data.data);
+        } else {
+          console.log('\n🔮 Revenue Forecast\n');
+
+          const trendIcon = trend.direction === 'up' ? '↑' : trend.direction === 'down' ? '↓' : '→';
+          outputPretty({
+            'Trend Direction': `${trendIcon} ${trend.direction}`,
+            'Daily Change': `¥${trend.daily_change.toFixed(2)}`,
+            'Based on': `${baseline_days} days of data`,
+          });
+
+          console.log('\n📅 Predicted Revenue\n');
+          outputPretty(
+            forecast.map((f) => ({
+              Date: f.date,
+              Day: f.day_of_week.slice(0, 3),
+              'Predicted Revenue': `¥${f.predicted_revenue.toFixed(2)}`,
+              Confidence: f.confidence,
+            })),
+            ['Date', 'Day', 'Predicted Revenue', 'Confidence']
+          );
+
+          info(disclaimer);
+        }
+      } catch (err: unknown) {
+        handleApiError(err);
+      }
+    });
+
+  return trends;
+}
+
+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);
+}

package/src/config/index.ts

@@ -0,0 +1,50 @@
+import Conf from 'conf';
+
+export interface CliConfig {
+  environment: 'production' | 'stage' | 'development';
+  authUrl: string;
+  backendUrl: string;
+  accessToken?: string;
+  refreshToken?: string;
+}
+
+export const config = new Conf<CliConfig>({
+  projectName: 'optima-bi-cli',
+  defaults: {
+    environment: 'production',
+    authUrl: 'https://auth.optima.chat',
+    backendUrl: 'https://bi-api.optima.chat',
+  },
+  encryptionKey: 'optima-bi-cli-secret-key-change-in-production',
+});
+
+/**
+ * Get CLI configuration.
+ *
+ * Supports environment variables for CI/development:
+ * - BI_CLI_TOKEN: Access token (overrides stored token)
+ * - BI_CLI_BACKEND_URL: Backend URL (overrides stored URL)
+ * - BI_CLI_AUTH_URL: Auth URL (overrides stored URL)
+ */
+export function getConfig(): CliConfig {
+  return {
+    environment: config.get('environment'),
+    authUrl: process.env.BI_CLI_AUTH_URL || config.get('authUrl'),
+    backendUrl: process.env.BI_CLI_BACKEND_URL || config.get('backendUrl'),
+    accessToken: process.env.BI_CLI_TOKEN || config.get('accessToken'),
+    refreshToken: config.get('refreshToken'),
+  };
+}
+
+export function setConfig(key: keyof CliConfig, value: any): void {
+  // Clear the key first if it exists and value is an object
+  if (config.has(key) && typeof value === 'object' && value !== null) {
+    config.delete(key);
+  }
+  config.set(key, value);
+}
+
+export function clearAuth(): void {
+  config.delete('accessToken');
+  config.delete('refreshToken');
+}

package/src/index.ts

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { createAuthCommand } from './commands/auth.js';
+import { createSalesCommand } from './commands/sales.js';
+import { createProductCommand } from './commands/product.js';
+import { createTrendsCommand } from './commands/trends.js';
+import { createAnalyticsCommand } from './commands/analytics.js';
+
+const program = new Command();
+
+program
+  .name('bi-cli')
+  .description('Optima BI CLI - AI-friendly business intelligence tool')
+  .version('0.2.0');
+
+// Auth commands
+program.addCommand(createAuthCommand());
+
+// Sales commands
+program.addCommand(createSalesCommand());
+
+// Product commands
+program.addCommand(createProductCommand());
+
+// Trends commands
+program.addCommand(createTrendsCommand());
+
+// Analytics commands
+program.addCommand(createAnalyticsCommand());
+
+// Config commands (placeholder)
+program
+  .command('config')
+  .description('Manage configuration')
+  .action(() => {
+    console.log('Config management coming soon...');
+  });
+
+// Customer commands (placeholder)
+program
+  .command('customer')
+  .description('Customer analytics')
+  .action(() => {
+    console.log('Customer analytics coming soon...');
+  });
+
+// Inventory commands (placeholder)
+program
+  .command('inventory')
+  .description('Inventory analytics')
+  .action(() => {
+    console.log('Inventory analytics coming soon...');
+  });
+
+// Platform commands (admin only - placeholder)
+program
+  .command('platform')
+  .description('Platform analytics (admin only)')
+  .action(() => {
+    console.log('Platform analytics coming soon...');
+  });
+
+program.parse();

package/src/utils/output.ts

@@ -0,0 +1,52 @@
+import chalk from 'chalk';
+import { table } from 'table';
+
+export enum OutputFormat {
+  JSON = 'json',
+  PRETTY = 'pretty',
+}
+
+export function outputJson(data: any): void {
+  console.log(JSON.stringify(data, null, 2));
+}
+
+export function outputPretty(data: any, headers?: string[]): void {
+  if (Array.isArray(data)) {
+    if (data.length === 0) {
+      console.log(chalk.yellow('No data found.'));
+      return;
+    }
+
+    const keys = headers || Object.keys(data[0]);
+    const rows = [keys.map((k) => chalk.bold(k))];
+
+    data.forEach((item) => {
+      rows.push(keys.map((k) => String(item[k] || '')));
+    });
+
+    console.log(table(rows));
+  } else {
+    // Single object
+    const rows: string[][] = [];
+    Object.entries(data).forEach(([key, value]) => {
+      rows.push([chalk.bold(key), String(value)]);
+    });
+    console.log(table(rows));
+  }
+}
+
+export function success(message: string): void {
+  console.log(chalk.green('✓ ' + message));
+}
+
+export function error(message: string): void {
+  console.error(chalk.red('✗ ' + message));
+}
+
+export function info(message: string): void {
+  console.log(chalk.blue('ℹ ' + message));
+}
+
+export function warn(message: string): void {
+  console.log(chalk.yellow('⚠ ' + message));
+}