fileflows 1.0.3 → 1.0.5

package/lib/dataFlowGrouper.js

@@ -1,150 +0,0 @@
-/**
- * Data flow grouping functionality
- * Groups files by actual data flow relationships (imports/exports)
- * @param {Array} fileList - List of files to analyze
- * @param {string} rootDir - Root directory path
- * @returns {Promise<Map>} Map of grouped files by data flow relationships
- */
-// 🚩AI: CORE_DATA_FLOW_ANALYSIS_ALGORITHM
-async function groupByDataFlow(fileList, rootDir) {
-  const fs = require(`fs`);
-  const path = require(`path`);
-  const localVars = require(`../config/localVars`);
-  const parseJSFile = require(`./jsParser`);
-  const parseOtherFile = require(`./otherFileParser`);
-  const classifyFile = require(`./fileClassifier`);
-  const extractDependencies = require(`./dependencyExtractor`);
-  
-  const dependencyGraph = new Map();
-  const fileMetadata = new Map();
-  
-  // Build dependency graph by analyzing imports/exports
-  for (const filePath of fileList) {
-    const fullPath = path.join(rootDir, filePath);
-    const ext = path.extname(filePath).slice(1);
-    
-    try {
-      const content = fs.readFileSync(fullPath, `utf8`);
-      let metadata = {};
-      
-      if (localVars.CODE_EXTENSIONS.includes(ext)) {
-        metadata = parseJSFile(content, filePath);
-      } else {
-        metadata = parseOtherFile(content, filePath, ext);
-      }
-      
-      fileMetadata.set(filePath, {
-        ...metadata,
-        type: classifyFile(filePath, ext),
-        dependencies: extractDependencies(metadata.Imports || [], filePath, fileList)
-      });
-      
-      dependencyGraph.set(filePath, metadata.Imports || []);
-    } catch (error) {
-      // File read error - skip this file
-      dependencyGraph.set(filePath, []);
-    }
-  }
-  
-  // Group files by connected components in dependency graph
-  const visited = new Set();
-  const groups = new Map();
-  let groupCounter = 1;
-  
-  function dfs(file, groupName, group) {
-    if (visited.has(file)) return;
-    visited.add(file);
-    group.push(file);
-    
-    // Visit all files that this file imports
-    const deps = fileMetadata.get(file)?.dependencies || [];
-    for (const dep of deps) {
-      if (!visited.has(dep)) {
-        dfs(dep, groupName, group);
-      }
-    }
-    
-    // Visit all files that import this file
-    for (const [otherFile, otherDeps] of fileMetadata) {
-      if (!visited.has(otherFile) && otherDeps.dependencies?.includes(file)) {
-        dfs(otherFile, groupName, group);
-      }
-    }
-  }
-  
-  // Create connected components
-  for (const file of fileList) {
-    if (!visited.has(file)) {
-      const group = [];
-      const groupName = `Group-${groupCounter++}`;
-      dfs(file, groupName, group);
-      
-      if (group.length > 0) {
-        groups.set(groupName, group);
-      }
-    }
-  }
-  
-  // SECONDARY: Use filename similarity for files without clear connections
-  const ungroupedFiles = fileList.filter(f => !visited.has(f));
-  if (ungroupedFiles.length > 0) {
-    const similarityGroups = groupBySimilarity(ungroupedFiles);
-    for (const [name, files] of similarityGroups) {
-      groups.set(`Similarity-${name}`, files);
-    }
-  }
-  
-  // Convert Map to Array format expected by tests
-  const groupArray = [];
-  for (const [groupName, files] of groups) {
-    groupArray.push({
-      name: groupName,
-      files: files,
-      metadata: files.map(f => fileMetadata.get(f)).filter(Boolean)
-    });
-  }
-  
-  return groupArray;
-}
-
-/**
- * Groups files by filename similarity when no data flow connections exist
- * @param {Array} files - Array of file paths
- * @returns {Map} Map of similarity-based groups
- */
-function groupBySimilarity(files) {
-  const path = require(`path`);
-  const groups = new Map();
-  
-  for (const file of files) {
-    const basename = path.basename(file, path.extname(file));
-    const parts = basename.split(/[-_.]/).filter(p => p.length > 2);
-    
-    let bestGroup = null;
-    let maxSimilarity = 0;
-    
-    for (const [groupName, groupFiles] of groups) {
-      const groupBasename = path.basename(groupFiles[0], path.extname(groupFiles[0]));
-      const groupParts = groupBasename.split(/[-_.]/).filter(p => p.length > 2);
-      
-      const commonParts = parts.filter(p => groupParts.includes(p));
-      const similarity = commonParts.length / Math.max(parts.length, groupParts.length);
-      
-      if (similarity > maxSimilarity && similarity > 0.3) {
-        maxSimilarity = similarity;
-        bestGroup = groupName;
-      }
-    }
-    
-    if (bestGroup) {
-      groups.get(bestGroup).push(file);
-    } else {
-      const key = parts.length > 0 ? parts[0] : basename;
-      groups.set(key, [file]);
-    }
-  }
-  
-  return groups;
-}
-
-module.exports = groupByDataFlow;

package/lib/dataFlowGrouper.test.js

@@ -1,17 +0,0 @@
-// Auto-generated unit test for dataFlowGrouper.js - optimized for speed
-const mod = require('./dataFlowGrouper.js');
-
-describe('dataFlowGrouper.js', () => {
-  test('groupByDataFlow works', async () => {
-    // Fast assertion - TODO: implement specific test logic
-    expect(typeof mod.groupByDataFlow).toBeDefined();
-  });
-  test('dfs works', async () => {
-    // Fast assertion - TODO: implement specific test logic
-    expect(typeof mod.dfs).toBeDefined();
-  });
-  test('groupBySimilarity works', async () => {
-    // Fast assertion - TODO: implement specific test logic
-    expect(typeof mod.groupBySimilarity).toBeDefined();
-  });
-});

package/lib/dependencyExtractor.js

@@ -1,70 +0,0 @@
-/**
- * Dependency extraction functionality
- * Extracts and resolves file dependencies from import statements
- * @param {Array} imports - Array of import statements
- * @param {string} currentFile - Current file path
- * @param {Array} fileList - List of all files in the project
- * @returns {Array} Array of resolved dependencies
- */
-function extractDependencies(imports, currentFile, fileList) {
-  const path = require(`path`);
-  const dependencies = [];
-  
-  for (const imp of imports) {
-    if (imp.startsWith(`.`)) {
-      // Relative import - try to resolve to actual file  
-      const basePath = path.dirname(currentFile);
-      let resolvedPath = path.normalize(path.join(basePath, imp));
-      
-      // Convert to forward slashes for cross-platform compatibility
-      resolvedPath = resolvedPath.replace(/\\/g, '/');
-      
-      // Handle different resolution scenarios:
-      // If resolvedPath starts with project structure, normalize it
-      // Remove src/ prefix if it exists and the target doesn't include it
-      const pathParts = resolvedPath.split('/');
-      
-      // Try original resolved path first, then variations
-      const possibleBasePaths = [
-        resolvedPath,
-        // Remove 'src/' prefix if present
-        pathParts[0] === 'src' ? pathParts.slice(1).join('/') : null,
-        // Handle cases where path goes up from src/ 
-        resolvedPath.replace(/^src\//, '')
-      ].filter(p => p && p !== resolvedPath); // Remove nulls and duplicates
-      
-      const allPossiblePaths = [resolvedPath, ...possibleBasePaths];
-      
-      // Try to find matching file with common extensions for each base path
-      for (const basePath of allPossiblePaths) {
-        if (!basePath) continue;
-        
-        const possiblePaths = [
-          basePath,
-          basePath + `.js`,
-          basePath + `.ts`, 
-          basePath + `.jsx`,
-          basePath + `.tsx`,
-          basePath + `/index.js`,
-          basePath + `/index.ts`
-        ];
-        
-        for (const possiblePath of possiblePaths) {
-          if (fileList.includes(possiblePath)) {
-            dependencies.push(possiblePath);
-            break;
-          }
-        }
-        
-        // If we found a match, stop looking
-        if (dependencies.some(dep => allPossiblePaths.some(base => dep.startsWith(base)))) {
-          break;
-        }
-      }
-    }
-  }
-  
-  return dependencies;
-}
-
-module.exports = extractDependencies;

package/lib/dependencyExtractor.test.js

@@ -1,9 +0,0 @@
-// Auto-generated unit test for dependencyExtractor.js - optimized for speed
-const mod = require('./dependencyExtractor.js');
-
-describe('dependencyExtractor.js', () => {
-  test('extractDependencies works', async () => {
-    // Fast assertion - TODO: implement specific test logic
-    expect(typeof mod.extractDependencies).toBeDefined();
-  });
-});

package/lib/fileClassifier.js

@@ -1,38 +0,0 @@
-/**
- * File classification functionality
- * Classifies files based on their path and extension
- * @param {string} filePath - The file path to classify
- * @param {string} ext - The file extension
- * @returns {string} Classification of the file type
- */
-function classifyFile(filePath, ext) {
-  const localVars = require(`../config/localVars`);
-  
-  if (localVars.CODE_EXTENSIONS.includes(ext)) {
-    // TSX files are specifically React/UI components (check first)
-    if (ext === `tsx`) return `UI Component`;
-    if (filePath.includes(`test`) || filePath.includes(`spec`)) return `Test File`;
-    if (filePath.includes(`component`) || filePath.includes(`Component`)) return `UI Component`;
-    if (filePath.includes(`api`) || filePath.includes(`route`)) return `API/Route`;
-    if (filePath.includes(`util`) || filePath.includes(`helper`)) return `Utility`;
-    if (filePath.includes(`config`) || filePath.includes(`setting`)) return `Configuration`;
-    if (filePath.includes(`model`) || filePath.includes(`schema`)) return `Data Model`;
-    return `Code File`;
-  }
-  
-  switch (ext) {
-    case `json`: return `Configuration/Data`;
-    case `md`: return `Documentation`;
-    case `yml`:
-    case `yaml`: return `Configuration`;
-    case `env`: return `Environment`;
-    case `html`: return `Template/View`;
-    case `css`:
-    case `scss`: return `Stylesheet`;
-    case `sh`: return `Script`;
-    case `graphql`: return `Schema`;
-    default: return `Other`;
-  }
-}
-
-module.exports = classifyFile;

package/lib/fileClassifier.test.js

@@ -1,9 +0,0 @@
-// Auto-generated unit test for fileClassifier.js - optimized for speed
-const mod = require('./fileClassifier.js');
-
-describe('fileClassifier.js', () => {
-  test('classifyFile works', async () => {
-    // Fast assertion - TODO: implement specific test logic
-    expect(typeof mod.classifyFile).toBeDefined();
-  });
-});

package/lib/fileFlowsGenerator.js

@@ -1,156 +0,0 @@
-/**
- * Main file flows generation functionality
- * Generates FILE_FLOWS.md documentation showing data flow relationships
- * @param {string} rootDir - Root directory to analyze (default: '.')
- * @param {string} outputFile - Output file path (default: 'FILE_FLOWS.md')
- * @returns {Promise<Object>} Generation result with statistics
- */
-// 🚩AI: ENTRY_POINT_FOR_FILE_FLOWS_GENERATION
-async function generateFileFlows(rootDir = `.`, outputFile = null) {
-  const fs = require(`fs`);
-  const path = require(`path`);
-  const localVars = require(`../config/localVars`);
-  const groupByDataFlow = require(`./dataFlowGrouper`);
-  const classifyFile = require(`./fileClassifier`);
-  const parseJSFile = require(`./jsParser`);
-  const parseOtherFile = require(`./otherFileParser`);
-  
-  const ROOT = rootDir;
-  const FILE_OUTPUT = outputFile || localVars.DEFAULT_OUTPUT_FILE;
-
-  // Use efficient file discovery with proper ignore patterns
-  let files = [];
-  try {
-    const { readdirSync, statSync } = require(`fs`);
-    const path = require(`path`);
-    
-    function shouldIgnore(relativePath) {
-      // Check against ignore patterns
-      return localVars.IGNORE_PATTERNS.some(pattern => {
-        const cleanPattern = pattern.replace(/\*\*/g, '').replace(/\*/g, '').replace(/\//g, '');
-        return relativePath.includes(cleanPattern);
-      });
-    }
-    
-    function findFiles(dir, depth = 0) {
-      // Prevent infinite recursion with depth limit
-      if (depth > 10) return [];
-      
-      const fullDirPath = path.join(ROOT, dir);
-      if (!fs.existsSync(fullDirPath)) return [];
-      
-      const items = readdirSync(fullDirPath);
-      const foundFiles = [];
-      
-      for (const item of items) {
-        const relativePath = dir === '.' ? item : path.join(dir, item).replace(/\\/g, '/');
-        
-        // Skip ignored items early
-        if (shouldIgnore(relativePath)) continue;
-        
-        try {
-          const fullPath = path.join(fullDirPath, item);
-          const stat = statSync(fullPath);
-          
-          if (stat.isDirectory()) {
-            // Recursive directory scan with depth tracking
-            foundFiles.push(...findFiles(relativePath, depth + 1));
-          } else if (stat.isFile()) {
-            const ext = path.extname(item).slice(1);
-            if (localVars.ALL_EXTENSIONS.includes(ext)) {
-              foundFiles.push(relativePath);
-            }
-          }
-        } catch (e) {
-          // Skip files/directories that can't be accessed
-          continue;
-        }
-      }
-      return foundFiles;
-    }
-    
-    files = findFiles('.');
-  } catch (error) {
-    require('qerrors').logError(error, 'File flow generation failed during file discovery', { 
-      context: 'FILE_DISCOVERY_ERROR',
-      rootDir: ROOT,
-      outputFile: FILE_OUTPUT 
-    });
-    return { filesAnalyzed: 0, flowGroups: 0, outputFile: null };
-  }
-
-  // Check if any files were found
-  if (files.length === 0) {
-    require('qerrors').logWarn(`No files found in directory: ${ROOT}`, 'generateFileFlows', { 
-      context: 'NO_FILES_FOUND',
-      rootDir: ROOT,
-      searchExtensions: localVars.ALL_EXTENSIONS 
-    });
-    return { filesAnalyzed: 0, flowGroups: 0, outputFile: null };
-  }
-
-  // PRIMARY: Group by data flow relationships
-  const grouped = await groupByDataFlow(files, ROOT);
-  const output = [];
-
-  output.push(`# FILE_FLOWS`);
-  output.push(`> Auto-generated. Do not edit directly.`);
-  output.push(`> Files grouped by PRIMARY: actual data flow relationships, SECONDARY: filename similarity.\n`);
-
-  let fileIndex = 1;
-  for (const group of grouped) {
-    const groupName = group.name || `Unknown-Group`;
-    const fileGroup = group.files || [];
-    output.push(`### 🧩 Flow Group: \`${groupName}\`\n`);
-    for (const relPath of fileGroup) {
-      const absPath = path.resolve(ROOT, relPath);
-      const ext = path.extname(relPath).slice(1);
-      
-      // 🚩AI: Safe file reading - skip files that don't exist to prevent test failures
-      let content;
-      try {
-        content = fs.readFileSync(absPath, `utf8`);
-      } catch (error) {
-        if (error.code === 'ENOENT') {
-          continue; // Skip files that don't exist
-        }
-        throw error; // Re-throw other errors
-      }
-      
-      const section = [`## [${fileIndex++}] \`${relPath}\``];
-
-      const fileType = classifyFile(relPath, ext);
-      section.push(`**Type:** ${fileType}`);
-
-      const metadata = localVars.CODE_EXTENSIONS.includes(ext) 
-        ? parseJSFile(content, relPath) 
-        : parseOtherFile(content, relPath, ext);
-        
-      for (const [label, value] of Object.entries(metadata)) {
-        // 🚩AI: Ensure value is always an array before calling join
-        const arrayValue = Array.isArray(value) ? value : [value];
-        if (arrayValue.length > 0) section.push(`**${label}:** ${arrayValue.join(`, `)}`);
-      }
-
-      section.push(`\n---\n`);
-      output.push(section.join(`\n`));
-    }
-  }
-
-  fs.writeFileSync(FILE_OUTPUT, output.join(`\n`));
-  const result = {
-    filesAnalyzed: fileIndex - 1,
-    flowGroups: grouped.length,
-    outputFile: FILE_OUTPUT
-  };
-  
-  require('qerrors').logInfo(`FILE_FLOWS.md generation completed`, 'generateFileFlows', { 
-    context: 'GENERATION_SUCCESS',
-    filesAnalyzed: result.filesAnalyzed,
-    flowGroups: result.flowGroups,
-    outputFile: result.outputFile
-  });
-  return result;
-}
-
-module.exports = generateFileFlows;

package/lib/fileFlowsGenerator.test.js

@@ -1,17 +0,0 @@
-// Auto-generated unit test for fileFlowsGenerator.js - optimized for speed
-const mod = require('./fileFlowsGenerator.js');
-
-describe('fileFlowsGenerator.js', () => {
-  test('generateFileFlows works', async () => {
-    // Fast assertion - TODO: implement specific test logic
-    expect(typeof mod.generateFileFlows).toBeDefined();
-  });
-  test('shouldIgnore works', async () => {
-    // Fast assertion - TODO: implement specific test logic
-    expect(typeof mod.shouldIgnore).toBeDefined();
-  });
-  test('findFiles works', async () => {
-    // Fast assertion - TODO: implement specific test logic
-    expect(typeof mod.findFiles).toBeDefined();
-  });
-});

package/lib/fileIO.js

@@ -1,60 +0,0 @@
-/**
- * File I/O utilities following Single Responsibility Principle
- * Centralized safe file reading with consistent error shapes
- * @param {string} rootDir - Root directory for relative path resolution
- * @param {string} filePath - File path to read
- * @returns {Object} Result object with success flag and content or error
- * @throws {Error} File system errors are caught and returned in error property
- */
-// 🚩AI: CORE_FILE_READING_UTILITIES
-function safeReadFileSync(rootDir, filePath) {
-  const fs = require(`fs`);
-  const path = require(`path`);
-  const qerrors = require(`qerrors`);
-  
-  try {
-    const fullPath = path.join(rootDir, filePath);
-    const content = fs.readFileSync(fullPath, `utf8`);
-    return { success: true, content };
-  } catch (error) {
-    require('qerrors').logError(error, `Failed to read file: ${filePath}`, { context: `FILE_READ_ERROR` });
-    return { success: false, error };
-  }
-}
-
-/**
- * Resolves file paths safely with validation
- * @param {string} rootDir - Root directory
- * @param {string} filePath - File path to resolve
- * @returns {Object} Result with success flag and resolved path or error
- * @throws {Error} Path traversal attempts and resolution errors caught and returned
- */
-function safeResolvePath(rootDir, filePath) {
-  const path = require(`path`);
-  const qerrors = require(`qerrors`);
-  
-  try {
-    const resolved = path.resolve(rootDir, filePath);
-    const relative = path.relative(rootDir, resolved);
-    
-    // Prevent directory traversal attacks
-    if (relative.startsWith(`..`)) {
-      const { createTypedError, ErrorTypes } = require('qerrors');
-      throw createTypedError(
-        `Path traversal attempt detected: ${filePath}`,
-        ErrorTypes.VALIDATION,
-        'PATH_TRAVERSAL_DETECTED'
-      );
-    }
-    
-    return { success: true, resolvedPath: resolved };
-  } catch (error) {
-    require('qerrors').logError(error, `Failed to resolve path: ${filePath}`, { context: `PATH_RESOLVE_ERROR` });
-    return { success: false, error };
-  }
-}
-
-module.exports = {
-  safeReadFileSync,
-  safeResolvePath
-};

package/lib/fileIO.test.js

@@ -1,13 +0,0 @@
-// Auto-generated unit test for fileIO.js - optimized for speed
-const mod = require('./fileIO.js');
-
-describe('fileIO.js', () => {
-  test('safeReadFileSync works', async () => {
-    // Fast assertion - TODO: implement specific test logic
-    expect(typeof mod.safeReadFileSync).toBeDefined();
-  });
-  test('safeResolvePath works', async () => {
-    // Fast assertion - TODO: implement specific test logic
-    expect(typeof mod.safeResolvePath).toBeDefined();
-  });
-});

package/lib/graphUtils.js

@@ -1,139 +0,0 @@
-/**
- * Graph utilities for dependency analysis and file grouping
- * Implements dependency graph building, connected components, and similarity grouping
- * Following Single Responsibility Principle for graph operations
- */
-// 🚩AI: CORE_GRAPH_ALGORITHMS
-
-/**
- * Builds dependency graph from file metadata
- * @param {Array<string>} fileList - List of file paths
- * @param {Map} fileMetadata - Map of file metadata containing dependencies
- * @returns {Map} Dependency graph mapping files to their dependencies
- */
-function buildDependencyGraph(fileList, fileMetadata) {
-  const graph = new Map();
-  
-  for (const filePath of fileList) {
-    const metadata = fileMetadata.get(filePath);
-    const dependencies = metadata?.dependencies || [];
-    graph.set(filePath, dependencies);
-  }
-  
-  return graph;
-}
-
-/**
- * Finds connected components in dependency graph using DFS
- * @param {Map} graph - Dependency graph
- * @returns {Array<Array<string>>} Array of connected component groups
- */
-function findConnectedComponents(graph) {
-  const visited = new Set();
-  const components = [];
-  
-  for (const node of graph.keys()) {
-    if (!visited.has(node)) {
-      const component = [];
-      depthFirstSearch(node, graph, visited, component);
-      if (component.length > 0) {
-        components.push(component);
-      }
-    }
-  }
-  
-  return components;
-}
-
-/**
- * Depth-first search for graph traversal
- * @param {string} node - Current node
- * @param {Map} graph - Dependency graph
- * @param {Set} visited - Set of visited nodes
- * @param {Array} component - Current component being built
- */
-function depthFirstSearch(node, graph, visited, component) {
-  if (visited.has(node)) return;
-  
-  visited.add(node);
-  component.push(node);
-  
-  const dependencies = graph.get(node) || [];
-  for (const dependency of dependencies) {
-    if (graph.has(dependency)) { // Only follow dependencies that exist in our file list
-      depthFirstSearch(dependency, graph, visited, component);
-    }
-  }
-}
-
-/**
- * Groups files by filename similarity for fallback grouping
- * @param {Array<string>} files - List of file paths
- * @returns {Map<string, Array<string>>} Map of similarity groups
- */
-function groupBySimilarity(files) {
-  const path = require(`path`);
-  const groups = new Map();
-  
-  for (const file of files) {
-    const basename = path.basename(file, path.extname(file));
-    const parts = basename.split(/[-_.]/).filter(part => part.length > 2);
-    
-    let bestGroupKey = null;
-    let maxSimilarity = 0;
-    
-    // Find most similar existing group
-    for (const [groupKey, groupFiles] of groups) {
-      const groupBasename = path.basename(groupFiles[0], path.extname(groupFiles[0]));
-      const groupParts = groupBasename.split(/[-_.]/).filter(part => part.length > 2);
-      
-      const commonParts = parts.filter(part => groupParts.includes(part));
-      const similarity = commonParts.length / Math.max(parts.length || 1, groupParts.length || 1);
-      
-      if (similarity > maxSimilarity && similarity > 0.3) {
-        maxSimilarity = similarity;
-        bestGroupKey = groupKey;
-      }
-    }
-    
-    if (bestGroupKey) {
-      groups.get(bestGroupKey).push(file);
-    } else {
-      // Create new group
-      const groupKey = basename.replace(/[-_.]/g, `-`);
-      groups.set(groupKey, [file]);
-    }
-  }
-  
-  return groups;
-}
-
-/**
- * Calculates role score for group naming
- * @param {string} filePath - File path to score
- * @returns {number} Role score for priority in naming
- */
-function calculateRoleScore(filePath) {
-  const path = require(`path`);
-  const basename = path.basename(filePath, path.extname(filePath)).toLowerCase();
-  const fullPath = filePath.toLowerCase();
-  
-  // Higher scores for more central/important files
-  let score = 0;
-  
-  if (basename.includes(`index`) || basename.includes(`main`)) score += 10;
-  if (basename.includes(`generator`) || basename.includes(`engine`)) score += 8;
-  if (basename.includes(`parser`) || basename.includes(`analyzer`)) score += 6;
-  if (basename.includes(`util`) || basename.includes(`helper`)) score += 4;
-  if (basename.includes(`config`) || basename.includes(`constant`) || fullPath.includes(`config/`)) score += 7;
-  
-  return score;
-}
-
-module.exports = {
-  buildDependencyGraph,
-  findConnectedComponents,
-  depthFirstSearch,
-  groupBySimilarity,
-  calculateRoleScore
-};