fileflows 1.0.2 → 1.0.5

package/dist/lib/fileClassifier.js

@@ -0,0 +1,78 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyFile = classifyFile;
+const localVars = __importStar(require("../config/localVars"));
+function classifyFile(filePath, ext) {
+    if (localVars.CODE_EXTENSIONS.includes(ext)) {
+        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';
+    }
+}

package/dist/lib/fileFlowsGenerator.js

@@ -0,0 +1,301 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFileFlows = generateFileFlows;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const qerrors_1 = __importDefault(require("qerrors"));
+const localVars = __importStar(require("../config/localVars"));
+const dataFlowGrouper_1 = require("./dataFlowGrouper");
+const fileClassifier_1 = require("./fileClassifier");
+const jsParser_1 = require("./jsParser");
+const otherFileParser_1 = require("./otherFileParser");
+const { logError, logWarn, logInfo } = qerrors_1.default;
+async function generateFileFlows(rootDir = '.', outputFile = null) {
+    const ROOT = rootDir;
+    const FILE_OUTPUT = outputFile || localVars.DEFAULT_OUTPUT_FILE;
+    const shouldIgnore = (relativePath) => {
+        return localVars.IGNORE_PATTERNS.some(pattern => {
+            const cleanPattern = pattern.replace(/\*\*/g, '').replace(/\*/g, '').replace(/\//g, '');
+            return relativePath.includes(cleanPattern);
+        });
+    };
+    const discoverFiles = () => {
+        const traverse = (dir, depth = 0) => {
+            if (depth > 10)
+                return [];
+            const fullDir = path_1.default.join(ROOT, dir);
+            if (!pathIsDirectory(fullDir))
+                return [];
+            const items = (0, fs_1.readdirSync)(fullDir);
+            const found = [];
+            for (const item of items) {
+                const relativePath = dir === '.' ? item : path_1.default.join(dir, item).replace(/\\/g, '/');
+                if (shouldIgnore(relativePath))
+                    continue;
+                try {
+                    const fullPath = path_1.default.join(fullDir, item);
+                    const stats = (0, fs_1.statSync)(fullPath);
+                    if (stats.isDirectory()) {
+                        found.push(...traverse(relativePath, depth + 1));
+                    }
+                    else if (stats.isFile()) {
+                        const ext = path_1.default.extname(item).slice(1);
+                        if (localVars.ALL_EXTENSIONS.includes(ext)) {
+                            found.push(relativePath);
+                        }
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            return found;
+        };
+        return traverse('.');
+    };
+    const files = discoverFiles();
+    if (files.length === 0) {
+        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, jsonOutputFile: null };
+    }
+    const grouped = await (0, dataFlowGrouper_1.groupByDataFlow)(files, ROOT);
+    const fileMetadata = grouped.fileMetadata || new Map();
+    const structuredOutput = buildStructuredFlowData(grouped, fileMetadata, files, fileClassifier_1.classifyFile);
+    const jsonOutputPath = getStructuredJsonPath(FILE_OUTPUT);
+    (0, fs_1.writeFileSync)(jsonOutputPath, JSON.stringify(structuredOutput, null, 2));
+    const outputLines = [];
+    outputLines.push('# FILE_FLOWS');
+    outputLines.push('> Auto-generated. Do not edit directly.');
+    outputLines.push('> Files grouped by PRIMARY: actual data flow relationships, SECONDARY: filename similarity.\n');
+    let flowIndex = 1;
+    let fileIndex = 1;
+    for (const group of grouped) {
+        const groupName = group.name || 'Unknown-Group';
+        const fileGroup = group.files || [];
+        outputLines.push(`### 🧩 Flow Group: [${flowIndex++}] \`${groupName}\`\n`);
+        for (const relPath of fileGroup) {
+            const absPath = path_1.default.resolve(ROOT, relPath);
+            const ext = path_1.default.extname(relPath).slice(1);
+            let content = '';
+            try {
+                content = (0, fs_1.readFileSync)(absPath, 'utf8');
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    continue;
+                }
+                throw error;
+            }
+            const metadata = localVars.CODE_EXTENSIONS.includes(ext)
+                ? parseJSMetadata(content, relPath)
+                : parseOtherMetadata(content, relPath, ext);
+            const section = [`## [${fileIndex++}] \`${relPath}\``];
+            section.push(`**Type:** ${(0, fileClassifier_1.classifyFile)(relPath, ext)}`);
+            const values = extractMetadataEntries(metadata);
+            values.forEach(entry => section.push(entry));
+            section.push('\n---\n');
+            outputLines.push(section.join('\n'));
+        }
+    }
+    (0, fs_1.writeFileSync)(FILE_OUTPUT, outputLines.join('\n'));
+    const result = {
+        filesAnalyzed: fileIndex - 1,
+        flowGroups: grouped.length,
+        outputFile: FILE_OUTPUT,
+        jsonOutputFile: jsonOutputPath
+    };
+    logInfo('FILE_FLOWS.md generation completed', 'generateFileFlows', {
+        context: 'GENERATION_SUCCESS',
+        filesAnalyzed: result.filesAnalyzed,
+        flowGroups: result.flowGroups,
+        outputFile: result.outputFile
+    });
+    return result;
+}
+function parseJSMetadata(content, relPath) {
+    return (0, jsParser_1.parseJSFile)(content, relPath);
+}
+function parseOtherMetadata(content, relPath, ext) {
+    return (0, otherFileParser_1.parseOtherFile)(content, relPath, ext);
+}
+function extractMetadataEntries(metadata) {
+    const entries = [];
+    for (const [label, value] of Object.entries(metadata)) {
+        const arrayValue = Array.isArray(value) ? value : [value];
+        if (arrayValue.length > 0) {
+            entries.push(`**${label}:** ${arrayValue.join(', ')}`);
+        }
+    }
+    return entries;
+}
+function pathIsDirectory(fullPath) {
+    try {
+        return (0, fs_1.statSync)(fullPath).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function buildStructuredFlowData(grouped, fileMetadata, allFiles, classifyFileFn) {
+    const fileToGroupMap = new Map();
+    grouped.forEach((group, idx) => {
+        for (const file of group.files || []) {
+            fileToGroupMap.set(file, idx);
+        }
+    });
+    const flowRelations = grouped.map(() => ({
+        importsFrom: new Set(),
+        importedBy: new Set()
+    }));
+    const createFallbackMetadata = (file) => ({
+        Imports: [],
+        Exports: [],
+        Functions: [],
+        Components: [],
+        ApiCalls: [],
+        ReduxActions: [],
+        Routes: [],
+        Keys: [],
+        Summary: [],
+        Headings: [],
+        Vars: [],
+        Types: [],
+        Commands: [],
+        Tags: [],
+        type: classifyFileFn(file, path_1.default.extname(file).slice(1)),
+        dependencies: [],
+        roleScore: 0
+    });
+    const flows = grouped.map((group, idx) => {
+        const dirCounts = {};
+        const internalDeps = new Set();
+        const externalDeps = new Set();
+        let totalRoleScore = 0;
+        const roleEntries = [];
+        const files = (group.files || []).map((file) => {
+            const meta = fileMetadata.get(file) ?? createFallbackMetadata(file);
+            const dependencies = meta.dependencies;
+            for (const dependency of dependencies) {
+                const targetGroup = fileToGroupMap.get(dependency);
+                if (targetGroup === idx) {
+                    internalDeps.add(dependency);
+                }
+                else if (typeof targetGroup === 'number') {
+                    flowRelations[idx].importsFrom.add(targetGroup);
+                    flowRelations[targetGroup].importedBy.add(idx);
+                }
+                else if (dependency) {
+                    externalDeps.add(dependency);
+                }
+            }
+            const roleScore = meta.roleScore;
+            totalRoleScore += roleScore;
+            roleEntries.push({ file, score: roleScore });
+            const dirName = path_1.default.dirname(file) || '.';
+            dirCounts[dirName] = (dirCounts[dirName] || 0) + 1;
+            return {
+                path: file,
+                type: meta.type,
+                roleScore,
+                imports: meta.Imports ?? [],
+                exports: meta.Exports ?? []
+            };
+        });
+        const averageScore = files.length ? totalRoleScore / files.length : 0;
+        const primaryEntry = roleEntries.reduce((best, entry) => {
+            if (!best || entry.score > best.score)
+                return entry;
+            return best;
+        }, null);
+        const sortedDirs = Object.entries(dirCounts).sort((a, b) => b[1] - a[1]);
+        const dominantDirectories = sortedDirs.slice(0, 3).map(([dir, count]) => ({
+            directory: dir,
+            fileCount: count
+        }));
+        return {
+            flowNumber: idx + 1,
+            name: group.name || `flow-${idx + 1}`,
+            fileCount: files.length,
+            metadata: group.metadata || [],
+            files,
+            hints: {
+                dominantDirectories,
+                internalDependencyCount: internalDeps.size,
+                externalDependencies: [...externalDeps].sort(),
+                roleScoreSummary: {
+                    average: Number(averageScore.toFixed(2)),
+                    highest: primaryEntry ? { path: primaryEntry.file, score: primaryEntry.score } : null
+                }
+            },
+            crossFlowDependencies: {
+                importsFrom: [],
+                importedBy: []
+            }
+        };
+    });
+    flows.forEach((flow, idx) => {
+        flow.crossFlowDependencies.importsFrom = Array.from(flowRelations[idx].importsFrom)
+            .map(groupIndex => flows[groupIndex]?.name)
+            .filter(Boolean);
+        flow.crossFlowDependencies.importedBy = Array.from(flowRelations[idx].importedBy)
+            .map(groupIndex => flows[groupIndex]?.name)
+            .filter(Boolean);
+    });
+    return {
+        generatedAt: new Date().toISOString(),
+        stats: {
+            flowCount: grouped.length,
+            fileCount: allFiles.length
+        },
+        flows
+    };
+}
+function getStructuredJsonPath(outputPath) {
+    if (!outputPath) {
+        return 'FILE_FLOWS.json';
+    }
+    const dir = path_1.default.dirname(outputPath);
+    const ext = path_1.default.extname(outputPath);
+    const baseName = ext ? path_1.default.basename(outputPath, ext) : path_1.default.basename(outputPath);
+    return path_1.default.join(dir, `${baseName}.json`);
+}

package/dist/lib/fileIO.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeReadFileSync = safeReadFileSync;
+exports.safeResolvePath = safeResolvePath;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const qerrors_1 = __importDefault(require("qerrors"));
+const { logError, createTypedError, ErrorTypes } = qerrors_1.default;
+function safeReadFileSync(rootDir, filePath) {
+    try {
+        const fullPath = path_1.default.join(rootDir, filePath);
+        return { success: true, content: (0, fs_1.readFileSync)(fullPath, 'utf8') };
+    }
+    catch (error) {
+        logError(error, `Failed to read file: ${filePath}`, { context: 'FILE_READ_ERROR' });
+        return { success: false, error: error };
+    }
+}
+function safeResolvePath(rootDir, filePath) {
+    try {
+        const resolved = path_1.default.resolve(rootDir, filePath);
+        const relative = path_1.default.relative(rootDir, resolved);
+        if (relative.startsWith('..')) {
+            throw createTypedError(`Path traversal attempt detected: ${filePath}`, ErrorTypes.VALIDATION, 'PATH_TRAVERSAL_DETECTED');
+        }
+        return { success: true, resolvedPath: resolved };
+    }
+    catch (error) {
+        logError(error, `Failed to resolve path: ${filePath}`, { context: 'PATH_RESOLVE_ERROR' });
+        return { success: false, error: error };
+    }
+}

package/dist/lib/graphUtils.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildDependencyGraph = buildDependencyGraph;
+exports.findConnectedComponents = findConnectedComponents;
+exports.depthFirstSearch = depthFirstSearch;
+exports.groupBySimilarity = groupBySimilarity;
+exports.calculateRoleScore = calculateRoleScore;
+const path_1 = __importDefault(require("path"));
+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;
+}
+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;
+}
+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)) {
+            depthFirstSearch(dependency, graph, visited, component);
+        }
+    }
+}
+function groupBySimilarity(files) {
+    const groups = new Map();
+    for (const file of files) {
+        const basename = path_1.default.basename(file, path_1.default.extname(file));
+        const parts = basename.split(/[-_.]/).filter(part => part.length > 2);
+        let bestGroupKey = null;
+        let maxSimilarity = 0;
+        for (const [groupKey, groupFiles] of groups) {
+            const groupBasename = path_1.default.basename(groupFiles[0], path_1.default.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 {
+            const groupKey = basename.replace(/[-_.]/g, '-');
+            groups.set(groupKey, [file]);
+        }
+    }
+    return groups;
+}
+function calculateRoleScore(filePath) {
+    const basename = path_1.default.basename(filePath, path_1.default.extname(filePath)).toLowerCase();
+    const fullPath = filePath.toLowerCase();
+    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;
+}

package/dist/lib/index.js

@@ -0,0 +1,50 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphUtils = exports.fileIO = exports.extractDependencies = exports.parseOtherFile = exports.parseJSFile = exports.classifyFile = exports.groupByDataFlow = exports.generateFileFlows = void 0;
+var fileFlowsGenerator_1 = require("./fileFlowsGenerator");
+Object.defineProperty(exports, "generateFileFlows", { enumerable: true, get: function () { return fileFlowsGenerator_1.generateFileFlows; } });
+var dataFlowGrouper_1 = require("./dataFlowGrouper");
+Object.defineProperty(exports, "groupByDataFlow", { enumerable: true, get: function () { return dataFlowGrouper_1.groupByDataFlow; } });
+var fileClassifier_1 = require("./fileClassifier");
+Object.defineProperty(exports, "classifyFile", { enumerable: true, get: function () { return fileClassifier_1.classifyFile; } });
+var jsParser_1 = require("./jsParser");
+Object.defineProperty(exports, "parseJSFile", { enumerable: true, get: function () { return jsParser_1.parseJSFile; } });
+var otherFileParser_1 = require("./otherFileParser");
+Object.defineProperty(exports, "parseOtherFile", { enumerable: true, get: function () { return otherFileParser_1.parseOtherFile; } });
+var dependencyExtractor_1 = require("./dependencyExtractor");
+Object.defineProperty(exports, "extractDependencies", { enumerable: true, get: function () { return dependencyExtractor_1.extractDependencies; } });
+exports.fileIO = __importStar(require("./fileIO"));
+exports.graphUtils = __importStar(require("./graphUtils"));

package/dist/lib/jsParser.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseJSFile = parseJSFile;
+const parser_1 = require("@babel/parser");
+const qerrors_1 = __importDefault(require("qerrors"));
+const { logWarn } = qerrors_1.default;
+function parseJSFile(content, filePath) {
+    const imports = new Set();
+    const exports = new Set();
+    const functions = new Set();
+    const components = new Set();
+    const apiCalls = new Set();
+    const reduxActions = new Set();
+    const routes = new Set();
+    try {
+        const ast = (0, parser_1.parse)(content, {
+            sourceType: 'module',
+            allowImportExportEverywhere: true,
+            plugins: ['jsx', 'typescript', 'decorators-legacy'],
+            errorRecovery: true
+        });
+        const visitNode = (node) => {
+            if (!node || typeof node !== 'object')
+                return;
+            switch (node.type) {
+                case 'ImportDeclaration': {
+                    const source = node.source?.value;
+                    if (source)
+                        imports.add(source);
+                    break;
+                }
+                case 'CallExpression': {
+                    if (node.callee?.name === 'require' && node.arguments?.[0]?.value) {
+                        const reqSource = node.arguments[0].value;
+                        const builtInModules = ['fs', 'path', 'http', 'https', 'os', 'util', 'crypto', 'events', 'stream'];
+                        if (!reqSource.startsWith('/') && !builtInModules.includes(reqSource)) {
+                            imports.add(reqSource);
+                        }
+                        else if (reqSource.startsWith('.')) {
+                            imports.add(reqSource);
+                        }
+                    }
+                    const callee = node.callee;
+                    if (callee?.type === 'MemberExpression') {
+                        const obj = callee.object?.name;
+                        const prop = callee.property?.name;
+                        if (['fetch', 'axios', 'http', 'https', 'api'].includes(obj) || ['get', 'post', 'put', 'delete', 'call'].includes(prop)) {
+                            apiCalls.add(`${obj}.${prop}`);
+                        }
+                        if (obj === 'dispatch' && prop) {
+                            reduxActions.add(prop);
+                        }
+                        if (['app', 'router', 'express'].includes(obj) && ['get', 'post', 'put', 'delete', 'patch'].includes(prop)) {
+                            const routeArg = node.arguments?.[0];
+                            if (routeArg?.value) {
+                                routes.add(`${prop.toUpperCase()} ${routeArg.value}`);
+                            }
+                        }
+                    }
+                    if (callee?.name === 'fetch' || callee?.name === 'axios') {
+                        apiCalls.add(`${callee.name}.call`);
+                    }
+                    break;
+                }
+                case 'ExportNamedDeclaration': {
+                    node.specifiers?.forEach((spec) => {
+                        if (spec.exported?.name)
+                            exports.add(spec.exported.name);
+                    });
+                    if (node.declaration?.declarations) {
+                        node.declaration.declarations.forEach((decl) => {
+                            if (decl.id?.name)
+                                exports.add(decl.id.name);
+                        });
+                    }
+                    if (node.declaration?.id?.name) {
+                        exports.add(node.declaration.id.name);
+                    }
+                    break;
+                }
+                case 'ExportDefaultDeclaration': {
+                    exports.add('default');
+                    break;
+                }
+                case 'FunctionDeclaration': {
+                    if (node.id?.name) {
+                        functions.add(node.id.name);
+                        if (node.id.name[0] === node.id.name[0].toUpperCase()) {
+                            components.add(node.id.name);
+                        }
+                    }
+                    break;
+                }
+                case 'VariableDeclarator': {
+                    if ((node.init?.type === 'ArrowFunctionExpression' || node.init?.type === 'FunctionExpression') && node.id?.name) {
+                        functions.add(node.id.name);
+                        if (node.id.name[0] === node.id.name[0].toUpperCase()) {
+                            components.add(node.id.name);
+                        }
+                    }
+                    break;
+                }
+            }
+            for (const key of Object.keys(node)) {
+                const value = node[key];
+                if (Array.isArray(value)) {
+                    value.forEach(visitNode);
+                }
+                else if (value && typeof value === 'object') {
+                    visitNode(value);
+                }
+            }
+        };
+        visitNode(ast);
+    }
+    catch (err) {
+        logWarn(`JavaScript parsing failed for ${filePath}`, 'parseJSFile', { context: 'JS_PARSE_ERROR', filePath, errorMessage: err.message });
+    }
+    return {
+        Imports: [...imports].sort(),
+        Exports: [...exports].sort(),
+        Functions: [...functions].sort(),
+        Components: [...components].sort(),
+        ApiCalls: [...apiCalls].sort(),
+        ReduxActions: [...reduxActions].sort(),
+        Routes: [...routes].sort()
+    };
+}