fileflows 1.0.3 → 1.0.5

package/README.md

@@ -56,16 +56,16 @@ npx fileflows
 npm run generate
 
 # Direct node execution
-node node_modules/fileflows/cli.js
+node node_modules/fileflows/cli.mjs
 ```
 
 ### Development/Direct Use
 ```bash
 # Clone or download the repository, then:
-node cli.js                    # Analyze current directory
-node cli.js --dir ./src        # Analyze src directory  
-node cli.js --output flows.md  # Custom output file
-node cli.js --help            # Show help
+node cli.mjs                    # Analyze current directory
+node cli.mjs --dir ./src        # Analyze src directory  
+node cli.mjs --output flows.md  # Custom output file
+node cli.mjs --help            # Show help
 ```
 
 ## How It Works
@@ -92,6 +92,14 @@ The generated `FILE_FLOWS.md` includes:
 - File type classification
 - Extracted metadata (imports, exports, functions, etc.)
 - Clear structure for understanding project architecture
+- Companion `FILE_FLOWS.json` containing the same flow groups, each file's metadata, hints about dominant directories/role scores, and cross-flow dependencies for machine consumption
+
+## Machine-readable Output
+
+- Every run now emits `FILE_FLOWS.json` beside `FILE_FLOWS.md`. It mirrors the Markdown groups and provides structured hints that allow downstream agents to identify which files belong together, which directories dominate a flow, how tightly coupled the group is, and what other flows it depends on.
+- When using `--output my-flows.md`, FileFlows also writes `my-flows.json` beside it.
+- Flow numbering matches the Markdown (`Flow Group [n]`) so orchestrators and humans can refer to the same labels.
+- **LLM agents should read `FILE_FLOWS.json` first** before consulting the Markdown. The structured JSON is the authoritative source for machine workflows; treat `FILE_FLOWS.md` as supplemental human-friendly documentation once the JSON is understood.
 
 ## Example Output
 
@@ -100,7 +108,7 @@ The generated `FILE_FLOWS.md` includes:
 > Auto-generated. Do not edit directly.
 > Files grouped by PRIMARY: actual data flow relationships, SECONDARY: filename similarity.
 
-### 🧩 Flow Group: `auth-flow`
+### 🧩 Flow Group: [1] `auth-flow`
 
 ## [1] `src/auth/login.js`
 **Type:** Feature Logic/UI
@@ -114,7 +122,7 @@ The generated `FILE_FLOWS.md` includes:
 ## Command Line Options
 
 ```
-Usage: node cli.js [options]
+Usage: fileflows [options]
 
 Options:
   --dir <path>     Directory to analyze (default: current directory)
@@ -122,9 +130,9 @@ Options:
   --help, -h       Show this help message
 
 Examples:
-  node cli.js                    # Analyze current directory
-  node cli.js --dir ./src        # Analyze src directory
-  node cli.js --output flows.md  # Custom output file
+  fileflows                    # Analyze current directory
+  fileflows --dir ./src        # Analyze src directory
+  fileflows --output flows.md  # Custom output file
 ```
 
-This tool preserves all the sophisticated analysis capabilities of the original system while providing a clean, focused CLI interface.
+This tool preserves all the sophisticated analysis capabilities of the original system while providing a clean, focused CLI interface.

package/cli.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { main } from './dist/cli.js';
+
+main().catch(error => {
+  console.error(error);
+  process.exit(1);
+});

package/config/jest-require-polyfill.cjs

@@ -0,0 +1,20 @@
+// Ensure a global require exists for ESM tests that use CommonJS require().
+// Executed by Jest via setupFiles BEFORE test files are evaluated.
+try {
+  if (typeof global.require === 'undefined') {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { createRequire } = require('module');
+    let req;
+    try {
+      req = createRequire(process.cwd() + '/package.json');
+    } catch {
+      req = createRequire(__filename);
+    }
+    Object.defineProperty(global, 'require', {
+      value: req,
+      writable: false,
+      configurable: true,
+      enumerable: false,
+    });
+  }
+} catch {}

package/config/jest-setup.mjs

@@ -0,0 +1,28 @@
+import 'qtests/setup';
+import { afterEach, beforeAll, jest as jestFromGlobals } from '@jest/globals';
+import { createRequire } from 'module';
+
+process.env.NODE_ENV = 'test';
+
+const J = jestFromGlobals ?? globalThis.jest;
+if (!globalThis.jest && J) {
+  globalThis.jest = J;
+}
+
+if (typeof globalThis.require !== 'function') {
+  globalThis.require = createRequire(import.meta.url);
+}
+
+beforeAll(() => {
+  const j = globalThis.jest ?? J;
+  if (j && typeof j.setTimeout === 'function') {
+    j.setTimeout(10000);
+  }
+});
+
+afterEach(() => {
+  const j = globalThis.jest ?? J;
+  if (j && typeof j.clearAllMocks === 'function') {
+    j.clearAllMocks();
+  }
+});

package/config/jest.config.mjs

@@ -0,0 +1,72 @@
+// jest.config.mjs - TypeScript ES Module configuration (React-enabled)
+// Use ESM export to avoid CommonJS issues under "type": "module"
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PROJECT_ROOT = path.resolve(__dirname, '..');
+
+export default {
+  preset: 'ts-jest/presets/default-esm',
+  rootDir: PROJECT_ROOT,
+  testEnvironment: 'node',
+  globals: {
+    'ts-jest': {
+      useESM: true,
+      tsconfig: 'tsconfig.jest.json'
+    }
+  },
+  // Ensure CommonJS require() exists in ESM tests
+  setupFiles: [path.join(PROJECT_ROOT, 'config', 'jest-require-polyfill.cjs')],
+  setupFilesAfterEnv: [path.join(PROJECT_ROOT, 'config', 'jest-setup.mjs')],
+  roots: [PROJECT_ROOT],
+  testMatch: [
+  "**/*.test.ts",
+  "**/*.test.tsx",
+  "**/*.spec.ts",
+  "**/*.spec.tsx",
+  "**/*.GenerateTest.test.ts",
+  "**/*.GenerateTest.test.tsx",
+  "**/*.GeneratedTest.test.ts",
+  "**/*.GeneratedTest.test.tsx",
+  "**/manual-tests/**/*.test.ts",
+  "**/generated-tests/**/*GeneratedTest*.test.ts",
+  "**/generated-tests/**/*GeneratedTest*.test.tsx"
+],
+  testPathIgnorePatterns: [
+  "/node_modules/",
+  "/dist/",
+  "/build/",
+  "/__mocks__/"
+],
+  // Harden ignores to avoid duplicate manual mocks and compiled artifacts
+  modulePathIgnorePatterns: ['<rootDir>/dist/', '<rootDir>/build/'],
+  watchPathIgnorePatterns: ['<rootDir>/dist/', '<rootDir>/build/'],
+  moduleFileExtensions: ["ts","tsx","js","jsx","json"],
+  transform: {
+  "^.+\\.(js|jsx)$": [
+    "babel-jest",
+    {}
+  ]
+},
+  extensionsToTreatAsEsm: [".ts",".tsx"],
+  transformIgnorePatterns: ['node_modules/(?!(?:qtests|@tanstack|@radix-ui|lucide-react|react-resizable-panels|cmdk|vaul)/)'],
+  moduleNameMapper: {
+  "^\\.\\./index\\.js$": "<rootDir>/index.ts",
+  "^\\.\\./setup\\.js$": "<rootDir>/setup.ts",
+  "^\\.\\./lib/(.*)\\.js$": "<rootDir>/lib/$1.ts",
+  "^\\.\\./lib/(.*)$": "<rootDir>/lib/$1.ts",
+  "^\\.\\./utils/httpTest\\.shim\\.js$": "<rootDir>/utils/httpTest.shim.js",
+  "^\\.\\./utils/(.*)\\.js$": "<rootDir>/utils/$1.ts",
+  "^(.*/httpTest\\.shim)\\.js$": "$1.js",
+  "^external-service-client$": "<rootDir>/utils/jest-proxies/external-service-client.cjs",
+  "^feature-x$": "<rootDir>/utils/jest-proxies/feature-x.cjs",
+  "^(\\.{1,2}/.*)\\.js$": "$1",
+  "^qtests/(.*)$": "<rootDir>/node_modules/qtests/dist/$1.js",
+  "^mongoose$": "<rootDir>/__mocks__/mongoose.js",
+  "^.+\\\\.(css|less|scss|sass)$": "<rootDir>/__mocks__/fileMock.js",
+  "^.+\\\\.(png|jpg|jpeg|gif|svg|webp|avif|ico|bmp)$": "<rootDir>/__mocks__/fileMock.js",
+  "^qtests$": "<rootDir>/types/qtests",
+  "^qerrors$": "<rootDir>/types/qerrors"
+}
+};

package/config/localVars.js

@@ -1,109 +1,2 @@
-/**
- * Configuration constants and environment variables
- * Single source of truth for all hardcoded values in the application
- * Following NPM architecture guidelines - DO NOT modify existing values
- */
-// 🚩AI: MUST_UPDATE_IF_FILE_EXTENSIONS_CHANGE
-
-// === FILE ANALYSIS CONSTANTS ===
-const CODE_EXTENSIONS = [`js`, `ts`, `jsx`, `tsx`];
-const ALL_EXTENSIONS = [...CODE_EXTENSIONS, `json`, `md`, `yml`, `yaml`, `env`, `html`, `css`, `scss`, `sh`, `graphql`];
-
-// === DEFAULT PATHS ===
-const DEFAULT_ROOT_DIR = `.`;
-const DEFAULT_OUTPUT_FILE = `FILE_FLOWS.md`;
-
-// === GITIGNORE PATTERNS ===
-const IGNORE_PATTERNS = [
-  `**/node_modules/**`,
-  `**/.config/**`,
-  `**/logs/**`,
-  `**/.git/**`,
-  `**/tmp/**`,
-  `**/temp/**`,
-  `**/.npm/**`,
-  `**/.cache/**`,
-  `**/dist/**`,
-  `**/build/**`,
-  `**/.next/**`,
-  `**/.nuxt/**`
-];
-
-// === PARSING LIMITS ===
-const MAX_JSON_KEYS = 10;
-const MAX_YAML_KEYS = 5;
-const MAX_SHELL_COMMANDS = 5;
-const MAX_HTML_TAGS = 5;
-
-// === CENTRALIZED DEPENDENCIES ===
-// All require statements moved from global scope to centralized configuration
-function getDependencies() {
-  return {
-    // Core library modules (from lib/index.js)
-    generateFileFlows: require(`../lib/fileFlowsGenerator`),
-    groupByDataFlow: require(`../lib/dataFlowGrouper`),
-    classifyFile: require(`../lib/fileClassifier`),
-    parseJSFile: require(`../lib/jsParser`),
-    parseOtherFile: require(`../lib/otherFileParser`),
-    extractDependencies: require(`../lib/dependencyExtractor`),
-    fileIO: require(`../lib/fileIO`),
-    graphUtils: require(`../lib/graphUtils`),
-    
-    // System dependencies (from qtests-runner.js)
-    fs: require(`fs`),
-    path: require(`path`),
-    childProcess: require(`child_process`),
-    os: require(`os`)
-  };
-}
-
-// === DEVELOPMENT DEPENDENCIES ===
-// Async loading for ES module dependencies (qtests is an ES module)
-async function getDevDependencies() {
-  // Check if this is a development environment and qtests is available
-  if (process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') {
-    try {
-      // Use dynamic import for ES modules
-      const qtests = await import('qtests');
-      return {
-        qtests: qtests
-      };
-    } catch (error) {
-      // qtests not available 
-      return {
-        qtests: null
-      };
-    }
-  }
-  
-  // Production environment - don't load qtests at all
-  return {
-    qtests: null
-  };
-}
-
-// === ENVIRONMENT VARIABLES ===
-// Centralized environment variable access using qerrors utilities
-const { getEnv } = require(`qerrors`);
-
-function getEnvironmentConfig() {
-  return {
-    NODE_ENV: getEnv(`NODE_ENV`, `development`),
-    DEBUG_TESTS: getEnv(`DEBUG_TESTS`, `false`) === `true`
-  };
-}
-
-module.exports = {
-  CODE_EXTENSIONS,
-  ALL_EXTENSIONS,
-  DEFAULT_ROOT_DIR,
-  DEFAULT_OUTPUT_FILE,
-  IGNORE_PATTERNS,
-  MAX_JSON_KEYS,
-  MAX_YAML_KEYS,
-  MAX_SHELL_COMMANDS,
-  MAX_HTML_TAGS,
-  getDependencies,
-  getDevDependencies,
-  getEnvironmentConfig
-};
+// This file proxies to the TypeScript-compiled configuration to maintain existing import paths.
+module.exports = require('../dist/config/localVars.js');

package/dist/cli.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showUsage = showUsage;
+exports.main = main;
+const localVars_1 = require("./config/localVars");
+const index_1 = require("./lib/index");
+function showUsage() {
+    console.log('Usage: fileflows [options]');
+    console.log('');
+    console.log('Options:');
+    console.log('  --dir <path>     Directory to analyze (default: current directory)');
+    console.log('  --output <file>  Output file path (default: FILE_FLOWS.md)');
+    console.log('  --help, -h       Show this help message');
+    console.log('');
+    console.log('Examples:');
+    console.log('  fileflows                    # Analyze current directory');
+    console.log('  fileflows --dir ./src        # Analyze src directory');
+    console.log('  fileflows --output flows.md  # Custom output file');
+}
+async function main(argv = process.argv.slice(2)) {
+    let rootDir = localVars_1.DEFAULT_ROOT_DIR;
+    let outputFile = null;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === '--help' || arg === '-h') {
+            showUsage();
+            process.exitCode = 0;
+            return;
+        }
+        if (arg === '--dir') {
+            if (i + 1 < argv.length) {
+                rootDir = argv[++i];
+            }
+            else {
+                console.error('Error: --dir requires a directory path');
+                process.exitCode = 1;
+                return;
+            }
+            continue;
+        }
+        if (arg === '--output') {
+            if (i + 1 < argv.length) {
+                outputFile = argv[++i];
+            }
+            else {
+                console.error('Error: --output requires a file path');
+                process.exitCode = 1;
+                return;
+            }
+            continue;
+        }
+        console.error(`Error: Unknown argument '${arg}'`);
+        showUsage();
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        console.log('🚀 Generating FILE_FLOWS.md...');
+        const result = await (0, index_1.generateFileFlows)(rootDir, outputFile);
+        if (result.outputFile && result.jsonOutputFile) {
+            console.log(`🧾 Wrote ${result.outputFile} and ${result.jsonOutputFile}`);
+        }
+        console.log('🎉 Generation complete!');
+    }
+    catch (error) {
+        console.error('❌ Error:', error.message);
+        process.exitCode = 1;
+    }
+}
+if (typeof require !== 'undefined' && require.main === module) {
+    main().catch(error => {
+        console.error(error);
+        process.exit(1);
+    });
+}

package/dist/config/localVars.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_HTML_TAGS = exports.MAX_SHELL_COMMANDS = exports.MAX_YAML_KEYS = exports.MAX_JSON_KEYS = exports.IGNORE_PATTERNS = exports.DEFAULT_OUTPUT_FILE = exports.DEFAULT_ROOT_DIR = exports.ALL_EXTENSIONS = exports.CODE_EXTENSIONS = void 0;
+exports.getDevDependencies = getDevDependencies;
+exports.getEnvironmentConfig = getEnvironmentConfig;
+exports.getDependencies = getDependencies;
+/**
+ * Centralized configuration values and helpers for the FileFlows CLI
+ * Exports environment helpers, ignore lists, and other shared constants
+ */
+const qerrors_1 = require("qerrors");
+exports.CODE_EXTENSIONS = ['js', 'ts', 'jsx', 'tsx'];
+exports.ALL_EXTENSIONS = [
+    ...exports.CODE_EXTENSIONS,
+    'json',
+    'md',
+    'yml',
+    'yaml',
+    'env',
+    'html',
+    'css',
+    'scss',
+    'sh',
+    'graphql'
+];
+exports.DEFAULT_ROOT_DIR = '.';
+exports.DEFAULT_OUTPUT_FILE = 'FILE_FLOWS.md';
+exports.IGNORE_PATTERNS = [
+    '**/node_modules/**',
+    '**/.config/**',
+    '**/logs/**',
+    '**/.git/**',
+    '**/tmp/**',
+    '**/temp/**',
+    '**/.npm/**',
+    '**/.cache/**',
+    '**/dist/**',
+    '**/build/**',
+    '**/.next/**',
+    '**/.nuxt/**'
+];
+exports.MAX_JSON_KEYS = 10;
+exports.MAX_YAML_KEYS = 5;
+exports.MAX_SHELL_COMMANDS = 5;
+exports.MAX_HTML_TAGS = 5;
+async function getDevDependencies() {
+    if (process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') {
+        try {
+            const qtests = await import('qtests/dist/index.js');
+            return { qtests };
+        }
+        catch {
+            return { qtests: null };
+        }
+    }
+    return { qtests: null };
+}
+function getEnvironmentConfig() {
+    return {
+        NODE_ENV: (0, qerrors_1.getEnv)('NODE_ENV', 'development'),
+        DEBUG_TESTS: (0, qerrors_1.getEnv)('DEBUG_TESTS', 'false') === 'true'
+    };
+}
+async function getDependencies() {
+    const { generateFileFlows, groupByDataFlow, classifyFile, parseJSFile, parseOtherFile, extractDependencies, fileIO, graphUtils } = await import('../lib/index.js');
+    return {
+        generateFileFlows,
+        groupByDataFlow,
+        classifyFile,
+        parseJSFile,
+        parseOtherFile,
+        extractDependencies,
+        fileIO,
+        graphUtils
+    };
+}

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFileFlows = void 0;
+var index_1 = require("./lib/index");
+Object.defineProperty(exports, "generateFileFlows", { enumerable: true, get: function () { return index_1.generateFileFlows; } });
+const index_2 = require("./lib/index");
+exports.default = index_2.generateFileFlows;

package/dist/lib/dataFlowGrouper.js

@@ -0,0 +1,137 @@
+"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.groupByDataFlow = groupByDataFlow;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const localVars = __importStar(require("../config/localVars"));
+const jsParser_1 = require("./jsParser");
+const otherFileParser_1 = require("./otherFileParser");
+const fileClassifier_1 = require("./fileClassifier");
+const dependencyExtractor_1 = require("./dependencyExtractor");
+const graphUtils = __importStar(require("./graphUtils"));
+async function groupByDataFlow(fileList, rootDir) {
+    const fileMetadata = new Map();
+    for (const filePath of fileList) {
+        const fullPath = path_1.default.join(rootDir, filePath);
+        const ext = path_1.default.extname(filePath).slice(1);
+        try {
+            const content = (0, fs_1.readFileSync)(fullPath, 'utf8');
+            const metadata = (localVars.CODE_EXTENSIONS.includes(ext)
+                ? (0, jsParser_1.parseJSFile)(content, filePath)
+                : (0, otherFileParser_1.parseOtherFile)(content, filePath, ext));
+            const roleScore = graphUtils.calculateRoleScore(filePath);
+            const metadataImports = Array.isArray(metadata.Imports) ? metadata.Imports : [];
+            fileMetadata.set(filePath, {
+                ...metadata,
+                type: (0, fileClassifier_1.classifyFile)(filePath, ext),
+                dependencies: (0, dependencyExtractor_1.extractDependencies)(metadataImports, filePath, fileList),
+                roleScore
+            });
+        }
+        catch {
+            fileMetadata.set(filePath, {
+                Imports: [],
+                Exports: [],
+                Functions: [],
+                Components: [],
+                ApiCalls: [],
+                ReduxActions: [],
+                Routes: [],
+                type: (0, fileClassifier_1.classifyFile)(filePath, ext),
+                dependencies: [],
+                roleScore: graphUtils.calculateRoleScore(filePath)
+            });
+        }
+    }
+    const dependencyGraph = graphUtils.buildDependencyGraph(fileList, fileMetadata);
+    const connectedComponents = graphUtils.findConnectedComponents(dependencyGraph);
+    const primaryGroups = [];
+    const similarityCandidates = [];
+    for (const component of connectedComponents) {
+        if (component.length > 1) {
+            primaryGroups.push(component);
+        }
+        else if (component.length === 1) {
+            similarityCandidates.push(component[0]);
+        }
+    }
+    const groupedResults = [];
+    let groupCounter = 1;
+    for (const component of primaryGroups) {
+        const previousName = buildFlowGroupName(component, groupCounter++, graphUtils);
+        groupedResults.push({
+            name: previousName,
+            files: component,
+            metadata: component
+                .map(f => fileMetadata.get(f))
+                .filter((item) => Boolean(item))
+        });
+    }
+    if (similarityCandidates.length > 0) {
+        const similarityGroups = graphUtils.groupBySimilarity(similarityCandidates);
+        for (const [name, files] of similarityGroups) {
+            groupedResults.push({
+                name: `Similarity-${name}`,
+                files,
+                metadata: files
+                    .map(f => fileMetadata.get(f))
+                    .filter((item) => Boolean(item))
+            });
+        }
+    }
+    const result = groupedResults;
+    result.fileMetadata = fileMetadata;
+    return result;
+}
+function buildFlowGroupName(component, counter, graph) {
+    const sorted = [...component].sort((a, b) => {
+        const scoreB = graph.calculateRoleScore(b);
+        const scoreA = graph.calculateRoleScore(a);
+        if (scoreB !== scoreA)
+            return scoreB - scoreA;
+        return a.localeCompare(b);
+    });
+    const primary = sorted[0];
+    const baseName = path_1.default
+        .basename(primary, path_1.default.extname(primary))
+        .replace(/[^a-zA-Z0-9]+/g, '-')
+        .replace(/^-|-$/g, '');
+    const normalized = baseName || 'flow';
+    return `${normalized}-${counter}`;
+}

package/dist/lib/dependencyExtractor.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractDependencies = extractDependencies;
+const path_1 = __importDefault(require("path"));
+function extractDependencies(imports, currentFile, fileList) {
+    const dependencies = [];
+    for (const imp of imports) {
+        if (!imp.startsWith('.')) {
+            continue;
+        }
+        const basePath = path_1.default.dirname(currentFile);
+        let resolvedPath = path_1.default.normalize(path_1.default.join(basePath, imp));
+        resolvedPath = resolvedPath.replace(/\\/g, '/');
+        const pathParts = resolvedPath.split('/');
+        const possibleBasePaths = [
+            resolvedPath,
+            pathParts[0] === 'src' ? pathParts.slice(1).join('/') : null,
+            resolvedPath.replace(/^src\//, '')
+        ].filter((value) => Boolean(value));
+        const allPossiblePaths = [resolvedPath, ...possibleBasePaths];
+        for (const basePathCandidate of allPossiblePaths) {
+            const possiblePaths = [
+                basePathCandidate,
+                `${basePathCandidate}.js`,
+                `${basePathCandidate}.ts`,
+                `${basePathCandidate}.jsx`,
+                `${basePathCandidate}.tsx`,
+                `${basePathCandidate}/index.js`,
+                `${basePathCandidate}/index.ts`
+            ];
+            for (const possiblePath of possiblePaths) {
+                if (fileList.includes(possiblePath)) {
+                    dependencies.push(possiblePath);
+                    break;
+                }
+            }
+            if (dependencies.some(dep => allPossiblePaths.some(base => dep.startsWith(base)))) {
+                break;
+            }
+        }
+    }
+    return dependencies;
+}