@arela/uploader 1.1.4 → 1.2.0

package/.claude/worktrees/agent-multi-profile/src/utils/PathDetector.js

@@ -0,0 +1,198 @@
+import path from 'path';
+
+/**
+ * Path Detection Utility
+ * Extracts year and pedimento information from file paths with caching
+ */
+export class PathDetector {
+  constructor() {
+    this.cache = new Map();
+  }
+
+  /**
+   * Extract year and pedimento number from file path with caching
+   * @param {string} filePath - Full file path
+   * @param {string} basePath - Base path to make relative
+   * @returns {Object} Detection result with year, pedimento, and detected flag
+   */
+  extractYearAndPedimentoFromPath(filePath, basePath) {
+    const cacheKey = `${filePath}|${basePath}`;
+
+    if (this.cache.has(cacheKey)) {
+      return this.cache.get(cacheKey);
+    }
+
+    const detection = this.#performDetection(filePath, basePath);
+    this.cache.set(cacheKey, detection);
+
+    return detection;
+  }
+
+  /**
+   * Perform the actual path detection
+   * @private
+   * @param {string} filePath - Full file path
+   * @param {string} basePath - Base path to make relative
+   * @returns {Object} Detection result
+   */
+  #performDetection(filePath, basePath) {
+    try {
+      const relativePath = path.relative(basePath, filePath);
+      const pathParts = relativePath.split(path.sep);
+
+      let year = null;
+      let pedimento = null;
+
+      // Pattern 1: Direct year/pedimento structure (2024/4023260)
+      year = this.#detectDirectPattern(pathParts);
+      pedimento = year ? this.#findPedimentoForYear(pathParts, year) : null;
+
+      // Pattern 2: Named patterns (año2024, ped4023260)
+      if (!year || !pedimento) {
+        const namedDetection = this.#detectNamedPatterns(pathParts);
+        year = year || namedDetection.year;
+        pedimento = pedimento || namedDetection.pedimento;
+      }
+
+      // Pattern 3: Loose year detection
+      if (!year) {
+        year = this.#detectLooseYear(pathParts);
+      }
+
+      // Pattern 4: Loose pedimento detection
+      if (!pedimento) {
+        pedimento = this.#detectLoosePedimento(pathParts);
+      }
+
+      return {
+        year,
+        pedimento,
+        detected: !!(year && pedimento),
+      };
+    } catch (error) {
+      return {
+        year: null,
+        pedimento: null,
+        detected: false,
+        error: error.message,
+      };
+    }
+  }
+
+  /**
+   * Detect direct year/pedimento pattern
+   * @private
+   * @param {string[]} pathParts - Path components
+   * @returns {string|null} Detected year
+   */
+  #detectDirectPattern(pathParts) {
+    for (let i = 0; i < pathParts.length - 1; i++) {
+      const yearMatch = pathParts[i].match(/^(202[0-9])$/);
+      if (yearMatch) {
+        return yearMatch[1];
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Find pedimento for a detected year
+   * @private
+   * @param {string[]} pathParts - Path components
+   * @param {string} year - Detected year
+   * @returns {string|null} Detected pedimento
+   */
+  #findPedimentoForYear(pathParts, year) {
+    const yearIndex = pathParts.findIndex((part) => part === year);
+    if (yearIndex >= 0 && yearIndex < pathParts.length - 1) {
+      const nextPart = pathParts[yearIndex + 1];
+      const pedimentoMatch = nextPart.match(/^(\d{4,8})$/);
+      if (pedimentoMatch) {
+        return pedimentoMatch[1];
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Detect named patterns (año2024, ped4023260)
+   * @private
+   * @param {string[]} pathParts - Path components
+   * @returns {Object} Detection result with year and pedimento
+   */
+  #detectNamedPatterns(pathParts) {
+    let year = null;
+    let pedimento = null;
+
+    for (const part of pathParts) {
+      if (!year) {
+        const namedYearMatch = part.match(/(?:año|year|anio)(\d{4})/i);
+        if (namedYearMatch) {
+          year = namedYearMatch[1];
+        }
+      }
+
+      if (!pedimento) {
+        const namedPedimentoMatch = part.match(
+          /(?:ped|pedimento|pedi)(\d{4,8})/i,
+        );
+        if (namedPedimentoMatch) {
+          pedimento = namedPedimentoMatch[1];
+        }
+      }
+    }
+
+    return { year, pedimento };
+  }
+
+  /**
+   * Detect loose year pattern
+   * @private
+   * @param {string[]} pathParts - Path components
+   * @returns {string|null} Detected year
+   */
+  #detectLooseYear(pathParts) {
+    for (const part of pathParts) {
+      const yearMatch = part.match(/(202[0-9])/);
+      if (yearMatch) {
+        return yearMatch[1];
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Detect loose pedimento pattern
+   * @private
+   * @param {string[]} pathParts - Path components
+   * @returns {string|null} Detected pedimento
+   */
+  #detectLoosePedimento(pathParts) {
+    for (const part of pathParts) {
+      const pedimentoMatch = part.match(/(\d{4,8})/);
+      if (pedimentoMatch && pedimentoMatch[1].length >= 4) {
+        return pedimentoMatch[1];
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Clear the detection cache
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+
+  /**
+   * Get cache size for monitoring
+   * @returns {number} Number of cached entries
+   */
+  getCacheSize() {
+    return this.cache.size;
+  }
+}
+
+// Export singleton instance
+export const pathDetector = new PathDetector();
+export default pathDetector;

package/.claude/worktrees/agent-multi-profile/src/utils/PathNormalizer.js

@@ -0,0 +1,274 @@
+import crypto from 'crypto';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+/**
+ * PathNormalizer - Absolute path resolution and table name generation
+ *
+ * Strategy:
+ * 1. Always resolve paths to absolute paths first (resolves ../sample vs ./sample)
+ * 2. Store absolute paths in base_path_full
+ * 3. Normalize ONLY for table name generation (sanitize special chars)
+ * 4. Keep full path structure in table names (hash if too long)
+ *
+ * Cross-platform support:
+ * - Recognizes Windows paths (C:\, D:\, etc.) even when running on macOS/Linux
+ * - Preserves Windows paths as-is when detected (for remote server scenarios)
+ * - This allows CLI running on macOS to work with paths stored from Windows servers
+ */
+export class PathNormalizer {
+  /**
+   * Check if a path is a Windows-style absolute path (has drive letter)
+   * This works on any OS, not just Windows
+   *
+   * Examples:
+   * - C:\Users\Documents -> true
+   * - O:\expediente\archivos -> true
+   * - /home/user/docs -> false
+   * - ./relative/path -> false
+   *
+   * @param {string} inputPath - Path to check
+   * @returns {boolean} True if path has a Windows drive letter
+   */
+  static isWindowsAbsolutePath(inputPath) {
+    if (!inputPath || typeof inputPath !== 'string') return false;
+    // Match drive letter followed by colon and backslash or forward slash
+    // e.g., C:\, D:/, O:\
+    return /^[A-Za-z]:[/\\]/.test(inputPath);
+  }
+
+  /**
+   * Check if a path is absolute (works cross-platform)
+   * Recognizes both Unix and Windows absolute paths regardless of current OS
+   *
+   * @param {string} inputPath - Path to check
+   * @returns {boolean} True if path is absolute (Unix or Windows style)
+   */
+  static isAbsolutePath(inputPath) {
+    if (!inputPath) return false;
+    // Check native absolute path first, then Windows-style
+    return path.isAbsolute(inputPath) || this.isWindowsAbsolutePath(inputPath);
+  }
+
+  /**
+   * Resolve a path to an absolute path
+   * This ensures ../sample and ./sample are treated as different paths
+   *
+   * Cross-platform behavior:
+   * - Windows paths (C:\, O:\, etc.) are preserved as-is, even on macOS/Linux
+   * - Unix paths are normalized using native path.resolve
+   * - Relative paths are resolved against basePath or cwd
+   *
+   * Examples:
+   * - ../sample (from /data/project) -> /data/sample
+   * - ./sample (from /data/project) -> /data/project/sample
+   * - C:\Users\Documents -> C:\Users\Documents (preserved on any OS)
+   * - O:\expediente\archivos -> O:\expediente\archivos (preserved on any OS)
+   * - /home/user/docs -> /home/user/docs (on Unix)
+   *
+   * @param {string} inputPath - Path to resolve
+   * @param {string} basePath - Base path for resolving relative paths (defaults to cwd)
+   * @returns {string} Absolute path (native format for Unix, preserved for Windows)
+   */
+  static toAbsolutePath(inputPath, basePath = null) {
+    if (!inputPath) return '';
+
+    // Check for Windows absolute path first (works on any OS)
+    // This prevents macOS from treating "O:\path" as relative
+    if (this.isWindowsAbsolutePath(inputPath)) {
+      // Normalize Windows path but preserve the format
+      // Replace forward slashes with backslashes for consistency
+      return inputPath.replace(/\//g, '\\');
+    }
+
+    // If native absolute path, return normalized
+    if (path.isAbsolute(inputPath)) {
+      return path.normalize(inputPath);
+    }
+
+    // Resolve relative path against base
+    const base = basePath || process.cwd();
+    return path.resolve(base, inputPath);
+  }
+
+  /**
+   * Normalize path separators to forward slashes for consistency
+   * Does NOT remove drive letters or convert to POSIX - just normalizes separators
+   *
+   * @param {string} inputPath - Path to normalize
+   * @returns {string} Path with forward slashes
+   */
+  static normalizeSeparators(inputPath) {
+    if (!inputPath) return '';
+    return inputPath.replace(/\\/g, '/');
+  }
+
+  /**
+   * Get relative path from base with normalized separators
+   *
+   * @param {string} fullPath - Full absolute path
+   * @param {string} basePath - Base absolute path to subtract
+   * @returns {string} Relative path with forward slashes
+   */
+  static getRelativePath(fullPath, basePath) {
+    const relativePath = path.relative(basePath, fullPath);
+    return this.normalizeSeparators(relativePath);
+  }
+
+  /**
+   * Sanitize an absolute path for use in database table names
+   * Converts path separators and special characters to underscores
+   * Preserves the path structure for uniqueness
+   *
+   * Examples:
+   * - /data/2023 -> data_2023
+   * - C:\Users\Documents -> c_users_documents
+   * - /home/user/project/sample -> home_user_project_sample
+   *
+   * @param {string} absolutePath - Absolute path to sanitize
+   * @returns {string} Sanitized string safe for table names
+   */
+  static sanitizeForTableName(absolutePath) {
+    if (!absolutePath) return '';
+
+    return absolutePath
+      .toLowerCase()
+      .replace(/^[a-z]:/i, '') // Remove Windows drive letter (C:, D:, etc.)
+      .replace(/[^a-z0-9]/g, '_') // Replace all non-alphanumeric with underscore
+      .replace(/_+/g, '_') // Replace multiple underscores with single
+      .replace(/^_|_$/g, ''); // Remove leading/trailing underscores
+  }
+
+  /**
+   * Generate a PostgreSQL-compatible table name from scan configuration
+   * Format: scan_<company>_<server>_<sanitized_absolute_path>
+   *
+   * Uses the absolute path to ensure uniqueness:
+   * - ../sample -> /data/sample
+   * - ./sample -> /data/project/sample
+   * These create different table names!
+   *
+   * Handles the 63-character PostgreSQL limit by:
+   * 1. Trying the full name first
+   * 2. If too long, truncating and adding an 8-character hash for uniqueness
+   *
+   * @param {Object} config - Scan configuration
+   * @param {string} config.companySlug - Company identifier
+   * @param {string} config.serverId - Server identifier
+   * @param {string} config.basePathLabel - Absolute base path
+   * @returns {string} PostgreSQL-compatible table name
+   */
+  static generateTableName(config) {
+    const { companySlug, serverId, basePathLabel } = config;
+
+    // Sanitize each component (basePathLabel should already be absolute)
+    const sanitizedCompany = companySlug
+      .toLowerCase()
+      .replace(/[^a-z0-9]/g, '_');
+    const sanitizedServer = serverId.toLowerCase().replace(/[^a-z0-9]/g, '_');
+    const sanitizedPath = this.sanitizeForTableName(basePathLabel);
+
+    // Build raw name for hashing (preserve original for uniqueness)
+    const rawName = `${companySlug}_${serverId}_${basePathLabel}`;
+
+    // Build sanitized table name
+    let tableName = `scan_${sanitizedCompany}_${sanitizedServer}`;
+
+    if (sanitizedPath) {
+      tableName += `_${sanitizedPath}`;
+    }
+
+    // PostgreSQL table name limit is 63 characters
+    if (tableName.length > 63) {
+      // Generate a hash for uniqueness
+      const hash = crypto
+        .createHash('md5')
+        .update(rawName)
+        .digest('hex')
+        .substring(0, 8);
+
+      const basePrefix = 'scan_';
+      const prefix = `${basePrefix}${sanitizedCompany}_${sanitizedServer}_`;
+
+      // Check if even prefix + hash exceeds limit
+      if (prefix.length + hash.length > 63) {
+        // Company/server names are too long, need to truncate them too
+        const maxCompanyServerLength = 63 - basePrefix.length - hash.length - 2; // -2 for underscores
+        const halfLength = Math.floor(maxCompanyServerLength / 2);
+        const companyLength = halfLength;
+        const serverLength = maxCompanyServerLength - companyLength;
+
+        const truncatedCompany = sanitizedCompany.substring(0, companyLength);
+        const truncatedServer = sanitizedServer.substring(0, serverLength);
+
+        tableName = `${basePrefix}${truncatedCompany}_${truncatedServer}_${hash}`;
+      } else {
+        // Preserve start and end of path, put hash in middle
+        const availableSpace = 63 - prefix.length - hash.length - 2; // -2 for underscores around hash
+
+        if (availableSpace <= 0 || !sanitizedPath) {
+          // If no space for path or path is empty, just use hash
+          tableName = `${prefix}${hash}`;
+        } else if (sanitizedPath.length <= availableSpace) {
+          // Path fits in available space, use it all
+          tableName = `${prefix}${sanitizedPath}_${hash}`;
+        } else {
+          // Need to split: preserve start and end
+          const halfSpace = Math.floor(availableSpace / 2);
+          const startLength = halfSpace;
+          const endLength = availableSpace - startLength;
+
+          // Extract start and end portions of the sanitized path
+          const pathStart = sanitizedPath.substring(0, startLength);
+          const pathEnd = sanitizedPath.substring(
+            sanitizedPath.length - endLength,
+          );
+
+          // Build table name with start, hash, and end
+          tableName = `${prefix}${pathStart}_${hash}_${pathEnd}`;
+        }
+      }
+    }
+
+    return tableName;
+  }
+
+  /**
+   * Build an absolute path from base and relative component
+   *
+   * @param {string} basePath - Absolute base path
+   * @param {string} relativePath - Relative path from base (can be empty)
+   * @returns {string} Absolute path
+   */
+  static buildAbsolutePath(basePath, relativePath = '') {
+    if (!relativePath || relativePath === '.') {
+      return basePath;
+    }
+    return path.resolve(basePath, relativePath);
+  }
+
+  /**
+   * Validate that a path can be used for table name generation
+   *
+   * @param {string} pathStr - Path to validate
+   * @returns {Object} Validation result { valid: boolean, error?: string }
+   */
+  static validatePath(pathStr) {
+    if (!pathStr || typeof pathStr !== 'string') {
+      return { valid: false, error: 'Path is required and must be a string' };
+    }
+
+    if (pathStr.trim() === '') {
+      return { valid: false, error: 'Path cannot be empty' };
+    }
+
+    // Check for null bytes (security)
+    if (pathStr.includes('\0')) {
+      return { valid: false, error: 'Path cannot contain null bytes' };
+    }
+
+    return { valid: true };
+  }
+}
+
+export default PathNormalizer;