arcvision 0.2.12 → 0.2.15

package/src/core/path-resolver.js

@@ -0,0 +1,240 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Resolve an import path to its actual file location
+ * Handles relative paths, path aliases, workspace packages, and node_modules
+ * @param {string} importPath - The import path from the source code
+ * @param {string} importerPath - The path of the file doing the import
+ * @param {string} projectRoot - The root directory of the project
+ * @param {Object|null} tsconfig - Loaded tsconfig with compilerOptions
+ * @param {Map<string, string>|null} workspaceMap - Map of package names to their roots
+ * @param {Set<string>|null} fileSet - Cached set of all absolute file paths
+ * @returns {string|null} The resolved absolute file path or null if not found
+ */
+function resolveImport(importPath, importerPath, projectRoot, tsconfig, workspaceMap, fileSet) {
+  // If it's an absolute path or URL, skip resolution
+  if (importPath.startsWith('http://') || importPath.startsWith('https://') ||
+    importPath.startsWith('data:') || importPath.startsWith('file:')) {
+    return null;
+  }
+
+  const exists = (p) => {
+    if (fileSet) return fileSet.has(p);
+    return fs.existsSync(p);
+  };
+
+  // Handle relative imports
+  if (importPath.startsWith('.')) {
+    // Resolve relative to importer
+    let resolvedPath = path.resolve(path.dirname(importerPath), importPath);
+
+    // Try with various extensions in order of preference
+    const extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.json'];
+    for (const ext of extensions) {
+      if (exists(resolvedPath + ext)) {
+        return resolvedPath + ext;
+      }
+    }
+
+    // Try as directory with index files
+    const indexFiles = ['index.ts', 'index.tsx', 'index.js', 'index.jsx', 'index.json'];
+    for (const idxFile of indexFiles) {
+      const indexPath = path.join(resolvedPath, idxFile);
+      if (exists(indexPath)) {
+        return indexPath;
+      }
+    }
+
+    // If original path exists as-is
+    if (exists(resolvedPath)) {
+      return resolvedPath;
+    }
+
+    return null;
+  }
+
+  // Handle path aliases (like @/components/, ~/utils/, etc.)
+  if (tsconfig && tsconfig.paths) {
+    const paths = tsconfig.paths;
+
+    // Sort aliases by length (descending) to match longer patterns first
+    const sortedAliases = Object.keys(paths).sort((a, b) => b.length - a.length);
+
+    for (const aliasPattern of sortedAliases) {
+      const aliasTargets = paths[aliasPattern];
+
+      // Handle pattern like "@/*" -> ["./src/*"]
+      if (aliasPattern.includes('*')) {
+        const patternBase = aliasPattern.replace(/\*.*$/, '');
+
+        // Match if it's the exact base (e.g. "@/utils" matches "@/utils/*") 
+        // OR if it starts with the base (e.g. "@/utils/foo" matches "@/utils/*")
+        if (importPath === patternBase.slice(0, -1) || importPath.startsWith(patternBase)) {
+          const suffix = importPath.length >= patternBase.length ?
+            importPath.substring(patternBase.length) : "";
+
+          for (const target of aliasTargets) {
+            const targetBase = target.replace(/\*.*$/, '');
+            const targetPath = path.resolve(projectRoot, path.join(targetBase, suffix));
+
+            // Try with extensions
+            const extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.json'];
+            for (const ext of extensions) {
+              if (exists(targetPath + ext)) {
+                return targetPath + ext;
+              }
+            }
+
+            // Try as directory with index files
+            const indexFiles = ['index.ts', 'index.tsx', 'index.js', 'index.jsx', 'index.json'];
+            for (const idxFile of indexFiles) {
+              const indexPath = path.join(targetPath, idxFile);
+              if (exists(indexPath)) {
+                return indexPath;
+              }
+            }
+
+            // Try exact path
+            if (exists(targetPath)) {
+              return targetPath;
+            }
+          }
+        }
+      } else {
+        // Handle exact match patterns
+        if (importPath === aliasPattern || importPath.startsWith(aliasPattern + '/')) {
+          for (const target of aliasTargets) {
+            let targetPath = path.resolve(projectRoot, target);
+
+            // If importPath is longer than the alias pattern, add the remaining part
+            if (importPath.length > aliasPattern.length) {
+              const remainingPath = importPath.substring(aliasPattern.length);
+              targetPath = path.join(targetPath, remainingPath);
+            }
+
+            // Try with extensions
+            const extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.json'];
+            for (const ext of extensions) {
+              if (exists(targetPath + ext)) {
+                return targetPath + ext;
+              }
+            }
+
+            // Try as directory with index files
+            const indexFiles = ['index.ts', 'index.tsx', 'index.js', 'index.jsx', 'index.json'];
+            for (const idxFile of indexFiles) {
+              const indexPath = path.join(targetPath, idxFile);
+              if (exists(indexPath)) {
+                return indexPath;
+              }
+            }
+
+            // Try exact path
+            if (exists(targetPath)) {
+              return targetPath;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Handle baseUrl if configured
+  if (tsconfig && tsconfig.baseUrl && !importPath.startsWith('.')) {
+    let resolvedPath = path.resolve(projectRoot, tsconfig.baseUrl, importPath);
+
+    // Try with extensions
+    const extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.json'];
+    for (const ext of extensions) {
+      if (exists(resolvedPath + ext)) {
+        return resolvedPath + ext;
+      }
+    }
+
+    // Try as directory with index files
+    const indexFiles = ['index.ts', 'index.tsx', 'index.js', 'index.jsx', 'index.json'];
+    for (const idxFile of indexFiles) {
+      const indexPath = path.join(resolvedPath, idxFile);
+      if (exists(indexPath)) {
+        return indexPath;
+      }
+    }
+
+    // Try exact path
+    if (exists(resolvedPath)) {
+      return resolvedPath;
+    }
+  }
+
+  // Handle Workspace Packages (Monorepo support)
+  if (workspaceMap && workspaceMap.has(importPath)) {
+    const packageRoot = workspaceMap.get(importPath);
+    // Look for entry point in package.json
+    try {
+      const pkgPath = path.join(packageRoot, 'package.json');
+      if (exists(pkgPath)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        const mainFile = pkg.main || pkg.module || 'index.js';
+        const searchPath = path.join(packageRoot, mainFile);
+
+        // Use standard node resolution logic on the main file
+        const extensions = ['', '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.json'];
+        for (const ext of extensions) {
+          const p = searchPath + ext;
+          if (exists(p)) return p;
+        }
+      }
+      // If no package.json or main, try index
+      const indexFiles = ['index.ts', 'index.tsx', 'index.js', 'index.jsx'];
+      for (const idx of indexFiles) {
+        const p = path.join(packageRoot, idx);
+        if (exists(p)) return p;
+      }
+    } catch (e) {
+      // ignore
+    }
+    // Fallback to pure directory path if nothing else
+    return packageRoot;
+  }
+
+  // Handle Workspace Sub-paths (e.g. "my-pkg/utils")
+  if (workspaceMap) {
+    // Find longest matching package name
+    // This is O(N) but N is number of packages, usually small.
+    for (const [pkgName, pkgRoot] of workspaceMap.entries()) {
+      if (importPath.startsWith(pkgName + '/')) {
+        const suffix = importPath.substring(pkgName.length + 1);
+        const targetPath = path.join(pkgRoot, suffix);
+
+        const extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.json', ''];
+        for (const ext of extensions) {
+          if (exists(targetPath + ext)) {
+            return targetPath + ext;
+          }
+        }
+        // Try as directory
+        const indexFiles = ['index.ts', 'index.tsx', 'index.js', 'index.jsx'];
+        for (const idx of indexFiles) {
+          const p = path.join(targetPath, idx);
+          if (exists(p)) return p;
+        }
+      }
+    }
+  }
+
+  // Handle node_modules resolution
+  if (!importPath.startsWith('.')) {
+    // Check if it's a node module
+    try {
+      const resolved = require.resolve(importPath, { paths: [path.dirname(importerPath)] });
+      return resolved;
+    } catch (e) {
+      // If require.resolve fails, it's not a node module
+    }
+  }
+
+  return null;
+}
+
+module.exports = { resolveImport };

package/src/core/pattern-matcher.js

@@ -0,0 +1,246 @@
+/**
+ * Robust Pattern Matching Utility
+ * Provides resilient pattern matching with graceful fallbacks
+ */
+
+const path = require('path');
+
+class PatternMatcher {
+  constructor() {
+    this.minimatch = null;
+    this.initialized = false;
+    this.initMinimatch();
+  }
+
+  /**
+   * Initialize minimatch with error handling
+   */
+  initMinimatch() {
+    const { dependencyManager } = require('./dependency-manager');
+    
+    this.minimatch = dependencyManager.safeImport('minimatch', null, { useCache: true });
+    
+    if (this.minimatch) {
+      this.initialized = true;
+      console.log('✅ Minimatch library initialized successfully');
+    } else {
+      console.warn('⚠️  Minimatch library not available');
+      console.warn('⚠️  Falling back to basic string matching');
+      this.minimatch = null;
+      this.initialized = false;
+    }
+  }
+
+  /**
+   * Robust pattern matching with multiple fallback strategies
+   */
+  match(filePath, pattern, options = {}) {
+    // Validate inputs
+    if (!filePath || typeof filePath !== 'string') {
+      return false;
+    }
+    
+    if (!pattern || typeof pattern !== 'string') {
+      return false;
+    }
+
+    // Try minimatch first if available
+    if (this.initialized && this.minimatch) {
+      try {
+        const matchOptions = {
+          matchBase: true,
+          dot: true,
+          ...options
+        };
+        
+        return this.minimatch.minimatch(filePath, pattern, matchOptions);
+      } catch (error) {
+        console.warn(`⚠️  Minimatch failed for pattern "${pattern}":`, error.message);
+        // Fall through to fallback methods
+      }
+    }
+
+    // Fallback 1: Basic glob matching (simple cases)
+    if (this.basicGlobMatch(filePath, pattern)) {
+      return true;
+    }
+
+    // Fallback 2: Path containment matching
+    if (this.pathContainmentMatch(filePath, pattern)) {
+      return true;
+    }
+
+    // Fallback 3: Extension matching
+    if (this.extensionMatch(filePath, pattern)) {
+      return true;
+    }
+
+    // Fallback 4: Exact filename matching
+    if (this.filenameMatch(filePath, pattern)) {
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Match array of patterns against file path
+   */
+  matchAny(filePath, patterns, options = {}) {
+    if (!Array.isArray(patterns)) {
+      return false;
+    }
+
+    return patterns.some(pattern => 
+      this.match(filePath, pattern, options)
+    );
+  }
+
+  /**
+   * Match all patterns against file path
+   */
+  matchAll(filePath, patterns, options = {}) {
+    if (!Array.isArray(patterns)) {
+      return false;
+    }
+
+    return patterns.every(pattern => 
+      this.match(filePath, pattern, options)
+    );
+  }
+
+  /**
+   * Basic glob pattern matching for simple cases
+   */
+  basicGlobMatch(filePath, pattern) {
+    // Handle simple wildcards
+    if (pattern === '**/*') return true;
+    if (pattern === '*') return true;
+    
+    // Handle extension patterns
+    if (pattern.startsWith('*.')) {
+      const ext = pattern.substring(1); // Remove *
+      return filePath.endsWith(ext);
+    }
+    
+    // Handle directory patterns
+    if (pattern.endsWith('/**')) {
+      const dir = pattern.slice(0, -3); // Remove /**
+      return filePath.includes(dir);
+    }
+    
+    // Handle simple contains
+    if (pattern.includes('*')) {
+      const parts = pattern.split('*');
+      let currentIndex = 0;
+      
+      for (const part of parts) {
+        if (part === '') continue;
+        const foundIndex = filePath.indexOf(part, currentIndex);
+        if (foundIndex === -1) return false;
+        currentIndex = foundIndex + part.length;
+      }
+      return true;
+    }
+    
+    return false;
+  }
+
+  /**
+   * Path containment matching
+   */
+  pathContainmentMatch(filePath, pattern) {
+    // Normalize paths for comparison
+    const normalizedFile = path.normalize(filePath).toLowerCase();
+    const normalizedPattern = path.normalize(pattern).toLowerCase();
+    
+    // Check if pattern is contained in file path
+    return normalizedFile.includes(normalizedPattern);
+  }
+
+  /**
+   * Extension matching
+   */
+  extensionMatch(filePath, pattern) {
+    if (!pattern.includes('.')) return false;
+    
+    const fileExt = path.extname(filePath).toLowerCase();
+    const patternExt = path.extname(pattern).toLowerCase();
+    
+    return fileExt === patternExt;
+  }
+
+  /**
+   * Filename matching (basename comparison)
+   */
+  filenameMatch(filePath, pattern) {
+    const fileName = path.basename(filePath);
+    const patternName = path.basename(pattern);
+    
+    // Exact match
+    if (fileName === patternName) return true;
+    
+    // Case insensitive match
+    if (fileName.toLowerCase() === patternName.toLowerCase()) return true;
+    
+    return false;
+  }
+
+  /**
+   * Get diagnostic information about matching capabilities
+   */
+  getDiagnostics() {
+    return {
+      minimatchAvailable: this.initialized,
+      minimatchVersion: this.minimatch ? require('minimatch/package.json').version : null,
+      fallbackMethods: [
+        'basicGlobMatch',
+        'pathContainmentMatch', 
+        'extensionMatch',
+        'filenameMatch'
+      ]
+    };
+  }
+
+  /**
+   * Test pattern matching with sample data
+   */
+  testPatterns() {
+    const testCases = [
+      { file: 'src/components/Button.jsx', pattern: '**/*.jsx', expected: true },
+      { file: 'src/utils/helpers.js', pattern: '**/utils/**', expected: true },
+      { file: 'package.json', pattern: '*.json', expected: true },
+      { file: 'src/App.tsx', pattern: '**/*.{ts,tsx}', expected: true },
+      { file: 'README.md', pattern: 'README.*', expected: true }
+    ];
+
+    console.log('🧪 Pattern Matching Diagnostics:');
+    console.log('==============================');
+    
+    const diagnostics = this.getDiagnostics();
+    console.log('Minimatch Available:', diagnostics.minimatchAvailable);
+    console.log('Fallback Methods:', diagnostics.fallbackMethods.length);
+    
+    console.log('\n🧪 Test Results:');
+    let passed = 0;
+    let failed = 0;
+    
+    testCases.forEach(({ file, pattern, expected }, index) => {
+      const result = this.match(file, pattern);
+      const status = result === expected ? '✅ PASS' : '❌ FAIL';
+      
+      if (result === expected) passed++;
+      else failed++;
+      
+      console.log(`${status} ${file} =~ ${pattern} (expected: ${expected}, got: ${result})`);
+    });
+    
+    console.log(`\n📊 Summary: ${passed}/${testCases.length} passed, ${failed} failed`);
+    return { passed, failed, total: testCases.length };
+  }
+}
+
+// Export singleton instance
+const patternMatcher = new PatternMatcher();
+
+module.exports = { PatternMatcher, patternMatcher };

package/src/core/progress-tracker.js

@@ -0,0 +1,71 @@
+const chalk = require('chalk');
+
+class ProgressTracker {
+  constructor(totalSteps) {
+    this.totalSteps = totalSteps;
+    this.currentStep = 0;
+    this.startTime = Date.now();
+  }
+
+  update(step, message) {
+    this.currentStep = step;
+    const progress = (this.currentStep / this.totalSteps) * 100;
+    const elapsed = Date.now() - this.startTime;
+    
+    // Format elapsed time
+    const elapsedSeconds = Math.floor(elapsed / 1000);
+    const minutes = Math.floor(elapsedSeconds / 60);
+    const seconds = elapsedSeconds % 60;
+    
+    const timeString = `${minutes}:${seconds.toString().padStart(2, '0')}`;
+    
+    console.log(
+      chalk.blue(`[${timeString}] `) +
+      chalk.yellow(`Progress: ${this.currentStep}/${this.totalSteps} (${Math.round(progress)}%) - ${message}`)
+    );
+  }
+
+  updateSimple(current, total, message) {
+    const progress = (current / total) * 100;
+    const elapsed = Date.now() - this.startTime;
+    
+    // Format elapsed time
+    const elapsedSeconds = Math.floor(elapsed / 1000);
+    const minutes = Math.floor(elapsedSeconds / 60);
+    const seconds = elapsedSeconds % 60;
+    
+    const timeString = `${minutes}:${seconds.toString().padStart(2, '0')}`;
+    
+    console.log(
+      chalk.blue(`[${timeString}] `) +
+      chalk.yellow(`Progress: ${current}/${total} (${Math.round(progress)}%) - ${message}`)
+    );
+  }
+
+  complete(message = 'Operation completed') {
+    const elapsed = Date.now() - this.startTime;
+    const elapsedSeconds = Math.floor(elapsed / 1000);
+    const minutes = Math.floor(elapsedSeconds / 60);
+    const seconds = elapsedSeconds % 60;
+    const timeString = `${minutes}:${seconds.toString().padStart(2, '0')}`;
+    
+    console.log(
+      chalk.green(`[${timeString}] ✓ ${message}`)
+    );
+  }
+
+  estimateRemaining(current, total) {
+    const elapsed = Date.now() - this.startTime;
+    const progress = current / total;
+    const estimatedTotalTime = elapsed / progress;
+    const remainingTime = estimatedTotalTime - elapsed;
+    
+    const remainingSeconds = Math.floor(remainingTime / 1000);
+    const minutes = Math.floor(remainingSeconds / 60);
+    const seconds = remainingSeconds % 60;
+    
+    return `${minutes}:${seconds.toString().padStart(2, '0')}`;
+  }
+}
+
+module.exports = ProgressTracker;