@arela/uploader 1.1.4 → 1.2.0

package/.claude/worktrees/agent-multi-profile/src/commands/IdentifyCommand.js

@@ -0,0 +1,708 @@
+import cliProgress from 'cli-progress';
+import fs from 'fs';
+import pLimit from 'p-limit';
+
+import logger from '../services/LoggingService.js';
+
+import appConfig from '../config/config.js';
+import ErrorHandler from '../errors/ErrorHandler.js';
+import { ConfigurationError } from '../errors/ErrorTypes.js';
+import FileDetectionService from '../file-detection.js';
+import { adaptDbMatchers } from '../scoring/db-matcher-adapter.js';
+import { scoringMatchers } from '../scoring/matchers-seed.js';
+
+/**
+ * Paid pedimento detected_type values.
+ */
+const DETECTED_PEDIMENTO_TYPES = new Set([
+  'pedimento_simplificado',
+  'pedimento_completo',
+  'pedimento_completo_xml',
+]);
+
+/** Unpaid pedimento detected_type values (proforma variants). */
+const PROFORMA_TYPES = new Set([
+  'proforma',
+  'proforma_completo',
+  'proforma_completo_xml',
+]);
+
+/**
+ * Identify Command Handler
+ * Optimized replacement for "detect --detect-pdfs"
+ * Identifies pedimento-simplificado documents in files scanned by "arela scan"
+ *
+ * Key improvements over legacy detect command:
+ * - Works with dynamic scan_* tables instead of uploader table
+ * - Uses configured API instead of direct Supabase access
+ * - Detects locally to leverage CLI host resources
+ * - Batch processing for efficient API communication
+ * - Real-time progress tracking
+ */
+export class IdentifyCommand {
+  constructor() {
+    this.errorHandler = new ErrorHandler(logger);
+    this.scanApiService = null; // Will be initialized in execute
+    this.detectionService = new FileDetectionService();
+  }
+
+  /**
+   * Execute the identify command
+   * @param {Object} options - Command options
+   * @param {string} options.api - API target (default, agencia, cliente)
+   * @param {number} options.batchSize - Batch size for API operations
+   * @param {boolean} options.showStats - Show performance statistics
+   * @param {Function} options.onProgress - Optional callback for progress updates (percent, message)
+   */
+  async execute(options = {}) {
+    const startTime = Date.now();
+    this.onProgress = options.onProgress || null;
+
+    try {
+      // Validate scan configuration (need same config as scan command)
+      appConfig.validateScanConfig();
+
+      // Determine API target
+      const apiTarget = options.api || 'default';
+
+      // Import ScanApiService dynamically and initialize with target
+      const { default: ScanApiService } = await import(
+        '../services/ScanApiService.js'
+      );
+      this.scanApiService = new ScanApiService(apiTarget);
+
+      // Load matchers for best-match classification (phase 4 hybrid). Prefer the
+      // DB-resolved set (this RFC + globals); fall back to the validated local
+      // seed; set DISABLE_SCORING_MATCHERS=true to force legacy first-match.
+      if (process.env.DISABLE_SCORING_MATCHERS === 'true') {
+        logger.info('🧩 Scoring matchers disabled — legacy detection');
+      } else {
+        let matchers = null;
+        try {
+          const rfc = process.env.MATCHER_RFC || null;
+          const dbMatchers = await this.scanApiService.getResolvedMatchers(rfc);
+          if (dbMatchers.length) {
+            matchers = adaptDbMatchers(dbMatchers);
+            logger.info(`🧩 Loaded ${matchers.length} matchers from API`);
+          }
+        } catch (err) {
+          logger.warn(`🧩 Could not load matchers from API: ${err.message}`);
+        }
+        if (!matchers) {
+          matchers = scoringMatchers;
+          logger.info(`🧩 Using local seed matchers (${matchers.length})`);
+        }
+        if (typeof this.detectionService.setMatchers === 'function') {
+          this.detectionService.setMatchers(matchers);
+        }
+      }
+
+      const scanConfig = appConfig.getScanConfig();
+      const batchSize = parseInt(options.batchSize) || 100;
+
+      // Parse optional path prefix mapping: "O:/=/Volumes/nas/"
+      const pathPrefixMap = options.pathPrefix
+        ? this.#parsePathPrefix(options.pathPrefix)
+        : null;
+
+      logger.info('🔍 Starting arela identify command');
+      logger.info(`🎯 API Target: ${apiTarget}`);
+      logger.info(`📦 Batch Size: ${batchSize}`);
+      if (options.table) logger.info(`📌 Target table: ${options.table}`);
+      if (options.resetAttempts)
+        logger.info('♻️  Reset detection attempts: ON');
+      if (pathPrefixMap)
+        logger.info(
+          `🗺  Path prefix map: ${pathPrefixMap.from} → ${pathPrefixMap.to}`,
+        );
+
+      // Resolve the list of tables to process
+      let tables;
+      if (options.fileId && options.table) {
+        // Single-file mode — identify exactly one file record
+        logger.info(
+          `\n🎯 Single-file mode: ${options.table} / ${options.fileId}`,
+        );
+        this.#reportProgress(0, `Fetching file record ${options.fileId}...`);
+        const record = await this.scanApiService.getFileRecord(
+          options.table,
+          options.fileId,
+        );
+        const results = await this.#detectFilesLocally(
+          [record],
+          1,
+          pathPrefixMap,
+        );
+        const updates = results.filter((r) => r !== null);
+        if (updates.length > 0) {
+          await this.scanApiService.batchUpdateDetection(
+            options.table,
+            updates,
+          );
+        }
+        this.#reportProgress(100, `Single-file identification complete`);
+        logger.success(`\n✅ Single-file identification complete`);
+        const firstUpdate = updates[0];
+        return {
+          processed: 1,
+          detected: updates.length,
+          proformas: 0,
+          errors: 1 - updates.length,
+          detectedType: firstUpdate?.detectedType ?? null,
+          detectedPedimento: firstUpdate?.detectedPedimento ?? null,
+          rfc: firstUpdate?.rfc ?? null,
+          arelaPath: firstUpdate?.arelaPath ?? null,
+        };
+      } else if (options.table) {
+        // Single-table mode — no need to match instance tables
+        tables = [{ tableName: options.table }];
+        logger.info(`\n📌 Single-table mode: ${options.table}`);
+      } else {
+        logger.info('\n📊 Fetching instance tables...');
+        tables = await this.scanApiService.getInstanceTables(
+          scanConfig.companySlug,
+          scanConfig.serverId,
+          scanConfig.basePathFull,
+        );
+
+        if (tables.length === 0) {
+          throw new ConfigurationError(
+            'No tables found for this instance. Run "arela scan" first.',
+          );
+        }
+
+        logger.info(
+          `📋 Found ${tables.length} table${tables.length === 1 ? '' : 's'} to process`,
+        );
+        for (const table of tables) {
+          logger.info(`   - ${table.tableName}`);
+        }
+      }
+
+      // Optionally reset detection attempts so previously-failed files are retried
+      if (options.resetAttempts) {
+        for (const table of tables) {
+          const { reset } = await this.scanApiService.resetDetectionAttempts(
+            table.tableName,
+          );
+          logger.info(
+            `♻️  Reset ${reset} detection attempt(s) in ${table.tableName}`,
+          );
+        }
+      }
+
+      // Process each table
+      let totalStats = {
+        processed: 0,
+        detected: 0,
+        proformas: 0,
+        errors: 0,
+        pending: 0,
+      };
+
+      // Report initial progress
+      this.#reportProgress(
+        0,
+        `Starting identification on ${tables.length} tables`,
+      );
+
+      for (let i = 0; i < tables.length; i++) {
+        const table = tables[i];
+        logger.info(`\n🔍 Processing table: ${table.tableName}`);
+        this.#reportProgress(
+          Math.round((i / tables.length) * 100),
+          `Processing table ${i + 1}/${tables.length}: ${table.tableName}`,
+        );
+
+        // Get detection statistics for this table
+        const stats = await this.#processTable(
+          table.tableName,
+          batchSize,
+          startTime,
+          pathPrefixMap,
+        );
+
+        totalStats.processed += stats.processed;
+        totalStats.detected += stats.detected;
+        totalStats.proformas += stats.proformas;
+        totalStats.errors += stats.errors;
+      }
+
+      const duration = ((Date.now() - startTime) / 1000).toFixed(2);
+      const avgSpeed =
+        duration > 0 ? Math.round(totalStats.processed / duration) : 0;
+
+      // Report completion
+      this.#reportProgress(
+        100,
+        `Identification completed: ${totalStats.detected} pedimentos detected`,
+      );
+
+      logger.success(`\n✅ Identification Complete!`);
+      logger.info(`\n📊 Total Results:`);
+      logger.info(`   Tables Processed: ${tables.length}`);
+      logger.info(`   Files Processed: ${totalStats.processed}`);
+      logger.info(`   Pedimentos Detected (paid): ${totalStats.detected}`);
+      logger.info(`   Proformas Detected (unpaid): ${totalStats.proformas}`);
+      logger.info(`   Errors: ${totalStats.errors}`);
+      logger.info(`   Duration: ${duration}s`);
+      logger.info(`   Speed: ${avgSpeed} files/sec`);
+
+      // Classification distribution for the run (observability: detect shifts /
+      // rising unmatched rate, and which detection mode was used).
+      if (
+        typeof this.detectionService.logClassificationSummary === 'function'
+      ) {
+        this.detectionService.logClassificationSummary(logger);
+      }
+
+      if (options.showStats) {
+        this.#showDetailedStats(
+          startTime,
+          totalStats.processed,
+          totalStats.detected,
+          totalStats.errors,
+        );
+      }
+    } catch (error) {
+      logger.error('❌ Identification failed:', error.message);
+
+      if (error instanceof ConfigurationError) {
+        logger.error('\nConfiguration errors:');
+        error.errors.forEach((err) => logger.error(`  - ${err}`));
+      }
+
+      throw error;
+    }
+  }
+
+  /**
+   * Process a single table
+   * @private
+   * @param {string} tableName - Table name to process
+   * @param {number} batchSize - Batch size
+   * @param {number} startTime - Start time for speed calculation
+   * @returns {Promise<Object>} Processing statistics
+   */
+  async #processTable(tableName, batchSize, startTime, pathPrefixMap = null) {
+    // Get detection statistics first (allTypes=true to count all supported file types)
+    const initialStats = await this.scanApiService.getDetectionStats(
+      tableName,
+      true,
+    );
+    logger.info(`   Total PDFs: ${initialStats.totalPdfs}`);
+    logger.info(`   Detected: ${initialStats.detected}`);
+    logger.info(`   Pending: ${initialStats.pending}`);
+    logger.info(`   Not Pedimento: ${initialStats.notPedimento || 0}`);
+    logger.info(
+      `   Max Attempts Reached: ${initialStats.maxAttemptsReached || 0}`,
+    );
+    logger.info(`   Errors: ${initialStats.errors}`);
+
+    if (initialStats.pending === 0) {
+      logger.info('   ✅ All PDFs processed. Skipping.');
+
+      if (initialStats.maxAttemptsReached > 0) {
+        logger.info(
+          `   ⚠️  ${initialStats.maxAttemptsReached} PDFs reached max attempts.`,
+        );
+      }
+
+      return {
+        processed: 0,
+        detected: 0,
+        // Must include every field totalStats accumulates — omitting proformas
+        // made `totalStats.proformas += undefined` = NaN in the final summary.
+        proformas: 0,
+        errors: 0,
+      };
+    }
+
+    logger.info(`   🚀 Processing ${initialStats.pending} pending PDFs...`);
+
+    logger.info(`   🚀 Processing ${initialStats.pending} pending PDFs...`);
+
+    // Setup progress bar
+    const progressBar = new cliProgress.SingleBar({
+      format:
+        '   📄 |{bar}| {percentage}% | {value}/{total} files | {speed} files/sec',
+      barCompleteChar: '\u2588',
+      barIncompleteChar: '\u2591',
+      hideCursor: true,
+    });
+
+    progressBar.start(initialStats.pending, 0, { speed: 0 });
+
+    let processedCount = 0;
+    let detectedCount = 0;
+    let proformaCount = 0;
+    let errorCount = 0;
+    let hasMore = true;
+    let batchNumber = 0;
+
+    // Process in batches
+    while (hasMore) {
+      batchNumber++;
+
+      // Fetch from offset 0 since processed files are filtered out
+      const response = await this.scanApiService.fetchPdfsForDetection(
+        tableName,
+        0,
+        batchSize,
+        true, // allTypes: fetch all supported file types, not just likely-simplificado PDFs
+      );
+
+      if (!response.data || response.data.length === 0) {
+        break;
+      }
+
+      const files = response.data;
+
+      // Detect files locally with concurrent processing
+      const detectionResults = await this.#detectFilesLocally(
+        files,
+        10,
+        pathPrefixMap,
+      );
+
+      // Batch update to API
+      const updateResult = await this.scanApiService.batchUpdateDetection(
+        tableName,
+        detectionResults,
+      );
+
+      // Update statistics
+      processedCount += files.length;
+      // "Detected" counts paid pedimentos of any flavour (simplificado,
+      // completo, completo_xml when enabled).
+      detectedCount += detectionResults.filter((r) =>
+        DETECTED_PEDIMENTO_TYPES.has(r.detectedType),
+      ).length;
+      proformaCount += detectionResults.filter((r) =>
+        PROFORMA_TYPES.has(r.detectedType),
+      ).length;
+      errorCount += detectionResults.filter((r) => r.detectionError).length;
+
+      // Update progress bar
+      const elapsed = (Date.now() - startTime) / 1000;
+      const speed = elapsed > 0 ? Math.round(processedCount / elapsed) : 0;
+      progressBar.update(processedCount, { speed });
+
+      // Check if there are more files
+      hasMore = response.hasMore;
+    }
+
+    progressBar.stop();
+
+    return {
+      processed: processedCount,
+      detected: detectedCount,
+      proformas: proformaCount,
+      errors: errorCount,
+    };
+  }
+
+  /**
+   * Detect files locally using FileDetectionService
+   * @private
+   * @param {Array} files - Files to detect
+   * @param {number} concurrency - Maximum concurrent detections
+   * @returns {Promise<Array>} Detection results
+   */
+  async #detectFilesLocally(files, concurrency = 10, pathPrefixMap = null) {
+    const limit = pLimit(concurrency);
+    const basePath = appConfig.getBasePath();
+
+    const detectionPromises = files.map((file) =>
+      limit(async () => {
+        try {
+          // Check if file exists on filesystem
+          let absolutePath = file.absolute_path;
+
+          // Apply cross-platform path prefix mapping if configured
+          if (
+            pathPrefixMap &&
+            absolutePath &&
+            absolutePath.startsWith(pathPrefixMap.from)
+          ) {
+            absolutePath =
+              pathPrefixMap.to + absolutePath.slice(pathPrefixMap.from.length);
+          }
+
+          if (!fs.existsSync(absolutePath)) {
+            return {
+              id: file.id,
+              detectedType: null,
+              detectedPedimento: null,
+              detectedPedimentoYear: null,
+              rfc: null,
+              arelaPath: null,
+              detectionError:
+                'FILE_NOT_FOUND: File does not exist on filesystem. May have been moved or deleted after scan.',
+              isPedimento: null, // Unknown - can't determine
+            };
+          }
+
+          // Check file size - skip very large files
+          const stats = fs.statSync(absolutePath);
+          const maxSizeBytes = 50 * 1024 * 1024; // 50MB
+          if (stats.size > maxSizeBytes) {
+            return {
+              id: file.id,
+              detectedType: null,
+              detectedPedimento: null,
+              detectedPedimentoYear: null,
+              rfc: null,
+              arelaPath: null,
+              detectionError: `FILE_TOO_LARGE: File size ${(stats.size / 1024 / 1024).toFixed(2)}MB exceeds ${maxSizeBytes / 1024 / 1024}MB limit.`,
+              isPedimento: null, // Unknown - can't determine
+            };
+          }
+
+          // Detect using existing FileDetectionService
+          const result = await this.detectionService.detectFile(absolutePath);
+
+          // If detection succeeded and found a paid pedimento (any variant)
+          if (DETECTED_PEDIMENTO_TYPES.has(result.detectedType)) {
+            return {
+              id: file.id,
+              detectedType: result.detectedType,
+              detectedPedimento: result.detectedPedimento,
+              detectedPedimentoYear: result.detectedPedimentoYear,
+              rfc: result.rfc,
+              arelaPath: result.arelaPath,
+              detectionError: result.error,
+              isPedimento: true, // Confirmed paid pedimento
+            };
+          }
+
+          // If detection succeeded and found a proforma (any variant)
+          if (PROFORMA_TYPES.has(result.detectedType)) {
+            return {
+              id: file.id,
+              detectedType: result.detectedType,
+              detectedPedimento: result.detectedPedimento,
+              detectedPedimentoYear: result.detectedPedimentoYear,
+              rfc: result.rfc,
+              arelaPath: null, // Proformas don't get arela_path (not paid yet)
+              detectionError: result.error,
+              isPedimento: false, // Not a paid pedimento — proforma only
+            };
+          }
+
+          // If no detection, determine if it's definitely not a pedimento
+          // This helps avoid re-processing files we know aren't pedimentos
+          const isDefinitelyNotPedimento = this.#isDefinitelyNotPedimento(
+            result,
+            file,
+          );
+
+          // Build descriptive error message
+          let detectionError = null;
+          if (result.error) {
+            detectionError = `DETECTION_ERROR: ${result.error}`;
+          } else if (isDefinitelyNotPedimento) {
+            detectionError =
+              'NOT_PEDIMENTO: File does not match any pedimento pattern. Missing key markers (e.g. "FORMA SIMPLIFICADA DE PEDIMENTO" or "NUM. PEDIMENTO:" + copy markers).';
+          } else {
+            // Partial match - might be a pedimento with missing fields
+            const missingFields = this.#getMissingFields(result);
+            if (missingFields.length > 0) {
+              detectionError = `INCOMPLETE_PEDIMENTO: Detected as potential pedimento but missing fields: ${missingFields.join(', ')}. Matcher may need improvement.`;
+            } else {
+              detectionError =
+                'UNKNOWN_ERROR: Detection completed but no pedimento found. Check file content and matcher patterns.';
+            }
+          }
+
+          return {
+            id: file.id,
+            detectedType: result.detectedType,
+            detectedPedimento: result.detectedPedimento,
+            detectedPedimentoYear: result.detectedPedimentoYear,
+            rfc: result.rfc,
+            arelaPath: result.arelaPath,
+            detectionError,
+            isPedimento: isDefinitelyNotPedimento ? false : null, // false = not pedimento, null = unknown
+          };
+        } catch (error) {
+          logger.warn(
+            `Failed to detect ${file.relative_path}: ${error.message}`,
+          );
+
+          // Categorize the error
+          let errorCategory = 'UNKNOWN_ERROR';
+          if (error.message.includes('ENOENT')) {
+            errorCategory = 'FILE_NOT_FOUND';
+          } else if (error.message.includes('timeout')) {
+            errorCategory = 'TIMEOUT';
+          } else if (error.message.includes('PDF')) {
+            errorCategory = 'PDF_PARSE_ERROR';
+          } else if (error.message.includes('extract')) {
+            errorCategory = 'TEXT_EXTRACTION_ERROR';
+          }
+
+          return {
+            id: file.id,
+            detectedType: null,
+            detectedPedimento: null,
+            detectedPedimentoYear: null,
+            rfc: null,
+            arelaPath: null,
+            detectionError: `${errorCategory}: ${error.message}`,
+            isPedimento: null, // Unknown - error occurred
+          };
+        }
+      }),
+    );
+
+    return Promise.all(detectionPromises);
+  }
+
+  /**
+   * Determine if a file is definitely not a pedimento/proforma document
+   * @private
+   * @param {Object} result - Detection result
+   * @param {Object} file - File metadata
+   * @returns {boolean} True if definitely not a pedimento/proforma
+   */
+  #isDefinitelyNotPedimento(result, file) {
+    // If we got any pedimento-related fields, it might be a pedimento or proforma
+    if (result.detectedPedimento || result.rfc || result.arelaPath) {
+      return false;
+    }
+
+    // If it was detected as a proforma (any variant), it's related to a
+    // pedimento structure — not "definitely not".
+    if (PROFORMA_TYPES.has(result.detectedType)) {
+      return false;
+    }
+
+    // Check if the text contains any required pedimento marker. This must
+    // stay aligned with the `match()` predicates in pedimento-simplificado.js
+    // and pedimento-completo.js (which accept both "DE" and "DEL" in the
+    // title, and treat the colon after "T. OPER" as optional).
+    const text = result.text || '';
+    const hasSimplificadoMarker =
+      /FORMA\s+SIMPLIFICADA\s+DEL?\s+PEDIMENTO/i.test(text);
+    const hasCompletoMarkers =
+      /NUM\.?\s*PEDIMENTO:/i.test(text) &&
+      /CVE\.?\s*PEDIMENTO:/i.test(text) &&
+      /T\.?\s*OPER:?/i.test(text);
+
+    return !hasSimplificadoMarker && !hasCompletoMarkers;
+  }
+
+  /**
+   * Get list of missing required fields for pedimento
+   * @private
+   * @param {Object} result - Detection result
+   * @returns {Array<string>} Missing field names
+   */
+  #getMissingFields(result) {
+    const requiredFields = [
+      { key: 'detectedPedimento', name: 'numPedimento' },
+      { key: 'rfc', name: 'rfc' },
+      { key: 'detectedPedimentoYear', name: 'year' },
+    ];
+
+    const missing = [];
+    for (const field of requiredFields) {
+      if (!result[field.key]) {
+        missing.push(field.name);
+      }
+    }
+
+    return missing;
+  }
+
+  /**
+   * Show detailed performance statistics
+   * @private
+   */
+  #showDetailedStats(startTime, processedCount, detectedCount, errorCount) {
+    const duration = (Date.now() - startTime) / 1000;
+    const avgSpeed = duration > 0 ? (processedCount / duration).toFixed(2) : 0;
+    const detectionRate =
+      processedCount > 0
+        ? ((detectedCount / processedCount) * 100).toFixed(1)
+        : 0;
+
+    logger.info('\n📈 Detailed Statistics:');
+    logger.info(`   Total Processing Time: ${duration.toFixed(2)}s`);
+    logger.info(`   Average Speed: ${avgSpeed} files/sec`);
+    logger.info(`   Detection Rate: ${detectionRate}%`);
+    logger.info(
+      `   Error Rate: ${errorCount > 0 ? ((errorCount / processedCount) * 100).toFixed(1) : 0}%`,
+    );
+
+    // Memory usage
+    const memUsage = process.memoryUsage();
+    logger.info('\n💾 Memory Usage:');
+    logger.info(`   RSS: ${(memUsage.rss / 1024 / 1024).toFixed(2)} MB`);
+    logger.info(
+      `   Heap Used: ${(memUsage.heapUsed / 1024 / 1024).toFixed(2)} MB`,
+    );
+    logger.info(
+      `   Heap Total: ${(memUsage.heapTotal / 1024 / 1024).toFixed(2)} MB`,
+    );
+  }
+
+  /**
+   * Report progress to callback if available (for worker mode)
+   * @private
+   * @param {number} percent - Progress percentage (0-100)
+   * @param {string} message - Progress message
+   */
+  #reportProgress(percent, message) {
+    if (this.onProgress && typeof this.onProgress === 'function') {
+      try {
+        this.onProgress(percent, message);
+      } catch (error) {
+        logger.debug(`Progress callback error: ${error.message}`);
+      }
+    }
+  }
+
+  /**
+   * Parse a path prefix mapping string such as "O:/=/Volumes/nas/" into { from, to }.
+   * Supports both "FROM=TO" and "FROM:TO" separators.
+   * @private
+   * @param {string} mapping
+   * @returns {{ from: string, to: string }}
+   */
+  #parsePathPrefix(mapping) {
+    // Support either "FROM=TO" or "FROM:TO" as separator
+    const eqIdx = mapping.indexOf('=');
+    const colonIdx = mapping.indexOf(':');
+
+    let sep = -1;
+    // "O:/=/Volumes" — the colon inside "O:/" is part of a Windows drive letter; prefer '=' separator
+    if (eqIdx !== -1) {
+      sep = eqIdx;
+    } else if (colonIdx !== -1) {
+      sep = colonIdx;
+    }
+
+    if (sep === -1) {
+      throw new Error(
+        `Invalid --path-prefix format: "${mapping}". Expected "FROM=TO" e.g. "O:/=/Volumes/nas/"`,
+      );
+    }
+
+    const from = mapping.slice(0, sep);
+    const to = mapping.slice(sep + 1);
+
+    if (!from || !to) {
+      throw new Error(
+        `Invalid --path-prefix format: "${mapping}". Both FROM and TO parts must be non-empty.`,
+      );
+    }
+
+    return { from, to };
+  }
+}
+
+// Export singleton instance
+const identifyCommand = new IdentifyCommand();
+export default identifyCommand;