intelwatch 1.2.0 → 1.3.2

package/src/utils/export.js

@@ -1,124 +1,200 @@
 import { writeFileSync } from 'fs';
-import { join } from 'path';
+import { resolve } from 'path';
+import * as XLSX from 'xlsx';
+import { isPro, requirePro, getLimits, applyFreeLimit, printPaywallAndExit } from '../license.js';
+
+// ── JSON Export ──────────────────────────────────────────────────────────────
 
 /**
- * Export data to JSON format
+ * Export data to JSON format.
+ * @param {any} data
+ * @param {string|null} outputPath
+ * @returns {string} Status message
  */
 export function exportToJSON(data, outputPath = null) {
   const jsonStr = JSON.stringify(data, null, 2);
-  
+
   if (outputPath) {
-    writeFileSync(outputPath, jsonStr, 'utf8');
+    writeFileSync(resolve(outputPath), jsonStr, 'utf8');
     return `Exported to ${outputPath}`;
   }
-  
-  // Print to console if no path specified
+
   console.log(jsonStr);
   return 'JSON output printed to console';
 }
 
+// ── CSV Export ────────────────────────────────────────────────────────────────
+
+/**
+ * Escape a value for CSV (RFC 4180 compliant).
+ * @param {any} value
+ * @returns {string}
+ */
+function escapeCSV(value) {
+  if (value == null) return '';
+  let str = typeof value === 'object'
+    ? (Array.isArray(value) ? value.join('; ') : JSON.stringify(value))
+    : String(value);
+  // Always quote if contains comma, double-quote, newline, or leading/trailing whitespace
+  if (str.includes(',') || str.includes('"') || str.includes('\n') || str.includes('\r') || str !== str.trim()) {
+    str = `"${str.replace(/"/g, '""')}"`;
+  }
+  return str;
+}
+
 /**
- * Export data to CSV format
- * Supports both flat objects and nested structures
+ * Export an array of objects to CSV.
+ * @param {Array<object>} data
+ * @param {string|null} outputPath
+ * @param {{ headers?: string[], separator?: string }} options
+ * @returns {string} Status message
  */
 export function exportToCSV(data, outputPath = null, options = {}) {
   if (!Array.isArray(data)) {
     throw new Error('CSV export requires an array of objects');
   }
-  
+
+  const sep = options.separator || ',';
+
   if (data.length === 0) {
-    const emptyCSV = options.headers ? options.headers.join(',') + '\n' : '';
+    const empty = options.headers ? options.headers.join(sep) + '\n' : '';
     if (outputPath) {
-      writeFileSync(outputPath, emptyCSV, 'utf8');
+      writeFileSync(resolve(outputPath), empty, 'utf8');
       return `Empty CSV exported to ${outputPath}`;
     }
-    console.log(emptyCSV);
+    console.log(empty);
     return 'Empty CSV output';
   }
 
-  // Auto-detect headers from first object if not provided
   const headers = options.headers || Object.keys(data[0]);
-  
-  // CSV header row
-  const csvRows = [headers.join(',')];
-  
-  // CSV data rows
+  const rows = [headers.join(sep)];
+
   for (const item of data) {
-    const row = headers.map(header => {
-      let value = item[header];
-      
-      // Handle nested objects/arrays
-      if (typeof value === 'object' && value !== null) {
-        if (Array.isArray(value)) {
-          value = value.join('; ');
-        } else {
-          value = JSON.stringify(value);
-        }
-      }
-      
-      // Escape CSV values
-      value = String(value || '');
-      if (value.includes(',') || value.includes('"') || value.includes('\n')) {
-        value = `"${value.replace(/"/g, '""')}"`;
-      }
-      
-      return value;
-    });
-    
-    csvRows.push(row.join(','));
+    const row = headers.map(h => escapeCSV(item[h]));
+    rows.push(row.join(sep));
   }
-  
-  const csvStr = csvRows.join('\n') + '\n';
-  
+
+  const csvStr = rows.join('\n') + '\n';
+
   if (outputPath) {
-    writeFileSync(outputPath, csvStr, 'utf8');
+    writeFileSync(resolve(outputPath), csvStr, 'utf8');
     return `CSV exported to ${outputPath}`;
   }
-  
+
   console.log(csvStr);
   return 'CSV output printed to console';
 }
 
+// ── XLS Export (xlsx format) ─────────────────────────────────────────────────
+
+/**
+ * Export data to XLSX (Excel) format.
+ * @param {Array<object>} data — rows to export
+ * @param {string} outputPath — output file (.xlsx)
+ * @param {{ sheetName?: string, headers?: string[] }} options
+ * @returns {string} Status message
+ */
+export function exportToXLS(data, outputPath, options = {}) {
+  if (!outputPath) throw new Error('XLS export requires an output path');
+  if (!Array.isArray(data)) throw new Error('XLS export requires an array of objects');
+
+  const sheetName = options.sheetName || 'Data';
+  const headers = options.headers || (data.length > 0 ? Object.keys(data[0]) : []);
+
+  // Build worksheet from array of arrays (header row + data rows)
+  const aoa = [headers];
+  for (const item of data) {
+    aoa.push(headers.map(h => {
+      const v = item[h];
+      if (v == null) return '';
+      if (Array.isArray(v)) return v.join('; ');
+      if (typeof v === 'object') return JSON.stringify(v);
+      return v;
+    }));
+  }
+
+  const wb = XLSX.utils.book_new();
+  const ws = XLSX.utils.aoa_to_sheet(aoa);
+
+  // Auto-size columns (approximate)
+  ws['!cols'] = headers.map((h, i) => {
+    let maxLen = h.length;
+    for (const row of aoa.slice(1)) {
+      const cellLen = String(row[i] || '').length;
+      if (cellLen > maxLen) maxLen = cellLen;
+    }
+    return { wch: Math.min(maxLen + 2, 60) };
+  });
+
+  XLSX.utils.book_append_sheet(wb, ws, sheetName);
+  XLSX.writeFile(wb, resolve(outputPath));
+  return `XLS exported to ${outputPath}`;
+}
+
+// ── PDF Export (via @recognity/pdf-report) ────────────────────────────────────
+
+/**
+ * Export data to a PDF report.
+ * @param {object} data — structured report data
+ * @param {string} outputPath — output file (.pdf)
+ * @param {{ type?: string, title?: string, branding?: object }} options
+ * @returns {Promise<string>} Status message
+ */
+export async function exportToPDF(data, outputPath, options = {}) {
+  if (!outputPath) throw new Error('PDF export requires an output path');
+
+  const { generatePDF } = await import('@recognity/pdf-report');
+  await generatePDF({
+    type: options.type || 'intel-report',
+    title: options.title || 'IntelWatch Report',
+    data,
+    output: resolve(outputPath),
+    branding: options.branding,
+  });
+
+  return `PDF exported to ${outputPath}`;
+}
+
+// ── Flatten Object ───────────────────────────────────────────────────────────
+
 /**
- * Flatten nested objects for CSV export
- * Example: { user: { name: 'John', age: 30 } } -> { 'user.name': 'John', 'user.age': 30 }
+ * Flatten nested objects for tabular export.
+ * { user: { name: 'Jo' } } → { 'user.name': 'Jo' }
  */
 export function flattenObject(obj, prefix = '', result = {}) {
-  for (const key in obj) {
-    if (obj.hasOwnProperty(key)) {
-      const newKey = prefix ? `${prefix}.${key}` : key;
-      
-      if (obj[key] && typeof obj[key] === 'object' && !Array.isArray(obj[key])) {
-        flattenObject(obj[key], newKey, result);
-      } else {
-        result[newKey] = obj[key];
-      }
+  for (const key of Object.keys(obj)) {
+    const newKey = prefix ? `${prefix}.${key}` : key;
+    const val = obj[key];
+    if (val && typeof val === 'object' && !Array.isArray(val) && !(val instanceof Date)) {
+      flattenObject(val, newKey, result);
+    } else {
+      result[newKey] = val;
     }
   }
   return result;
 }
 
+// ── Format for Export ────────────────────────────────────────────────────────
+
 /**
- * Format data for export based on command type
+ * Format data for export based on command type.
+ * @param {any} data
+ * @param {string} commandType
+ * @returns {Array<object>}
  */
 export function formatForExport(data, commandType) {
   switch (commandType) {
-    case 'check':
-      return formatCheckData(data);
-    case 'digest':
-      return formatDigestData(data);
-    case 'report':
-      return formatReportData(data);
-    case 'profile':
-      return formatProfileData(data);
-    default:
-      return data;
+    case 'check':     return formatCheckData(data);
+    case 'digest':    return formatDigestData(data);
+    case 'report':    return formatReportData(data);
+    case 'profile':   return formatProfileData(data);
+    case 'discover':  return formatDiscoverData(data);
+    default:          return Array.isArray(data) ? data : [data];
   }
 }
 
 function formatCheckData(data) {
   if (!Array.isArray(data)) return [data];
-  
   return data.map(item => ({
     trackerId: item.id || item.trackerId,
     name: item.name,
@@ -129,41 +205,32 @@ function formatCheckData(data) {
     changes: Array.isArray(item.changes) ? item.changes.length : 0,
     techStack: Array.isArray(item.techStack) ? item.techStack.join('; ') : '',
     seoScore: item.seoScore || null,
-    sentiment: item.sentiment || null
+    sentiment: item.sentiment || null,
   }));
 }
 
 function formatDigestData(data) {
   if (!Array.isArray(data)) return [data];
-  
   return data.map(item => flattenObject({
-    tracker: {
-      id: item.trackerId,
-      name: item.name,
-      type: item.type
-    },
+    tracker: { id: item.trackerId, name: item.name, type: item.type },
     changes: {
       total: item.changes?.length || 0,
       critical: item.changes?.filter(c => c.severity === 'critical').length || 0,
       major: item.changes?.filter(c => c.severity === 'major').length || 0,
-      minor: item.changes?.filter(c => c.severity === 'minor').length || 0
+      minor: item.changes?.filter(c => c.severity === 'minor').length || 0,
     },
-    summary: item.summary || ''
+    summary: item.summary || '',
   }));
 }
 
 function formatReportData(data) {
-  // For reports, export the raw data structure
   return Array.isArray(data) ? data : [data];
 }
 
 function formatProfileData(data) {
   if (!data) return [];
-  
   const profile = Array.isArray(data) ? data[0] : data;
-  
-  const flattened = {
-    // Company identity
+  return [{
     siren: profile.siren,
     name: profile.name || profile.identity?.name,
     legalForm: profile.identity?.formeJuridique,
@@ -171,31 +238,86 @@ function formatProfileData(data) {
     nafLabel: profile.identity?.nafLabel,
     creationDate: profile.identity?.dateCreation,
     address: profile.identity?.adresse,
-    
-    // Financial data (latest year)
     revenue: profile.financialHistory?.[0]?.revenue,
     netIncome: profile.financialHistory?.[0]?.netIncome,
     employees: profile.financialHistory?.[0]?.employees,
     year: profile.financialHistory?.[0]?.year,
-    
-    // AI analysis
     executiveSummary: profile.executiveSummary,
     healthScore: profile.healthScore?.score,
     riskLevel: profile.riskAssessment?.overall,
-    
-    // Strengths (concatenated)
     strengths: profile.strengths?.map(s => s.text || s).join('; ') || '',
-    
-    // Weaknesses (concatenated)
     weaknesses: profile.weaknesses?.map(w => w.text || w).join('; ') || '',
-    
-    // Competitors (concatenated)
     competitors: profile.competitors?.map(c => c.name).join('; ') || '',
-    
-    // Group info
     subsidiariesCount: profile.subsidiaries?.length || 0,
-    groupRevenue: profile.groupStructure?.consolidatedRevenue
-  };
-  
-  return [flattened];
-}
+    groupRevenue: profile.groupStructure?.consolidatedRevenue,
+  }];
+}
+
+function formatDiscoverData(data) {
+  if (!Array.isArray(data)) return [data];
+  return data.map(item => ({
+    name: item.name || item.domain,
+    domain: item.domain,
+    url: item.url,
+    relevanceScore: item.relevanceScore || item.score,
+    description: item.description || item.snippet || '',
+    category: item.category || '',
+  }));
+}
+
+// ── Unified Export Handler ───────────────────────────────────────────────────
+
+/**
+ * Handle --export flag for any command.
+ *
+ * Free tier:  json, csv (capped at 50 rows)
+ * Pro tier:   json, csv (unlimited), xls, pdf
+ *
+ * @param {string} format — 'json' | 'csv' | 'xls' | 'pdf'
+ * @param {any} data — data to export
+ * @param {{ output?: string, commandType?: string, pdfOptions?: object }} options
+ * @returns {Promise<string>} Status message
+ */
+export async function handleExport(format, data, options = {}) {
+  const fmt = format.toLowerCase();
+  const limits = getLimits();
+
+  // Gate Pro-only formats — clean paywall exit
+  if (['xls', 'xlsx', 'excel', 'pdf'].includes(fmt)) {
+    if (!isPro()) {
+      printPaywallAndExit(`Export to ${fmt.toUpperCase()}`);
+    }
+  }
+
+  let formatted = options.commandType
+    ? formatForExport(data, options.commandType)
+    : (Array.isArray(data) ? data : [data]);
+
+  // Apply Free-tier row cap on CSV
+  if (fmt === 'csv' && Array.isArray(formatted)) {
+    formatted = applyFreeLimit(formatted, limits.csvMaxRows, 'CSV export rows');
+  }
+
+  switch (fmt) {
+    case 'json': {
+      const outPath = options.output?.replace(/\.[^.]+$/, '.json') || null;
+      return exportToJSON(formatted, outPath);
+    }
+    case 'csv': {
+      const outPath = options.output?.replace(/\.[^.]+$/, '.csv') || null;
+      return exportToCSV(formatted, outPath);
+    }
+    case 'xls':
+    case 'xlsx':
+    case 'excel': {
+      const outPath = options.output?.replace(/\.[^.]+$/, '.xlsx') || 'export.xlsx';
+      return exportToXLS(formatted, outPath);
+    }
+    case 'pdf': {
+      const outPath = options.output?.replace(/\.[^.]+$/, '.pdf') || 'export.pdf';
+      return exportToPDF(options.pdfData || data, outPath, options.pdfOptions || {});
+    }
+    default:
+      throw new Error(`Unsupported export format: ${format}. Use json, csv, xls, or pdf.`);
+  }
+}