@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/mutation/file-impact-scan.js

@@ -0,0 +1,182 @@
+"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.estimateFileMutationImpact = estimateFileMutationImpact;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const SOURCE_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", ".cjs"]);
+const RESOLVABLE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", ".cjs", ".json"];
+const EXCLUDED_DIRS = new Set([".git", ".tmp", "node_modules", "dist", "dist-stable", "out", "build", "coverage"]);
+const MAX_SCANNED_FILES = 6_000;
+const MAX_FILE_BYTES = 1_000_000;
+function estimateFileMutationImpact(cwd, sourceFiles) {
+    const sourceFileCount = sourceFiles.length;
+    const existingSources = sourceFiles
+        .map((file) => path.resolve(cwd, file))
+        .filter((file) => fs.existsSync(file));
+    const sourceBases = new Set(existingSources
+        .map((file) => normalizeResolvedModuleBase(file))
+        .filter((file) => file.length > 0));
+    if (sourceBases.size === 0) {
+        return emptyImpact(sourceFileCount, existingSources.length);
+    }
+    const importingFiles = new Set();
+    let importStatementCount = 0;
+    let barrelExportCount = 0;
+    let scannedFileCount = 0;
+    let truncated = false;
+    for (const file of collectSourceFiles(path.resolve(cwd))) {
+        scannedFileCount += 1;
+        if (scannedFileCount > MAX_SCANNED_FILES) {
+            truncated = true;
+            break;
+        }
+        if (sourceBases.has(normalizeResolvedModuleBase(file))) {
+            continue;
+        }
+        const text = readSmallTextFile(file);
+        if (text === null) {
+            continue;
+        }
+        for (const occurrence of collectModuleSpecifierOccurrences(text)) {
+            const resolved = resolveImportBase(file, occurrence.specifier);
+            if (!resolved || !sourceBases.has(resolved)) {
+                continue;
+            }
+            importingFiles.add(file);
+            importStatementCount += 1;
+            if (occurrence.kind === "export") {
+                barrelExportCount += 1;
+            }
+        }
+    }
+    return {
+        sourceFileCount,
+        existingSourceFileCount: existingSources.length,
+        importingFileCount: importingFiles.size,
+        importStatementCount,
+        barrelExportCount,
+        scannedFileCount: Math.min(scannedFileCount, MAX_SCANNED_FILES),
+        truncated
+    };
+}
+function collectSourceFiles(root) {
+    const result = [];
+    const stack = [root];
+    while (stack.length > 0 && result.length <= MAX_SCANNED_FILES) {
+        const dir = stack.pop();
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (!EXCLUDED_DIRS.has(entry.name)) {
+                    stack.push(fullPath);
+                }
+                continue;
+            }
+            if (entry.isFile() && SOURCE_EXTENSIONS.has(path.extname(entry.name))) {
+                result.push(fullPath);
+                if (result.length > MAX_SCANNED_FILES) {
+                    break;
+                }
+            }
+        }
+    }
+    return result;
+}
+function collectModuleSpecifierOccurrences(text) {
+    const occurrences = [];
+    collectPattern(occurrences, text, /\bimport\s+(?:type\s+)?(?:[^"'`]*?\s+from\s*)?["']([^"']+)["']/g, "import");
+    collectPattern(occurrences, text, /\bexport\s+(?:type\s+)?[^"'`]*?\s+from\s*["']([^"']+)["']/g, "export");
+    collectPattern(occurrences, text, /\bimport\s*\(\s*["']([^"']+)["']\s*\)/g, "import");
+    collectPattern(occurrences, text, /\brequire\s*\(\s*["']([^"']+)["']\s*\)/g, "import");
+    return occurrences;
+}
+function collectPattern(occurrences, text, pattern, kind) {
+    for (const match of text.matchAll(pattern)) {
+        const specifier = match[1];
+        if (specifier) {
+            occurrences.push({ specifier, kind });
+        }
+    }
+}
+function resolveImportBase(fromFile, specifier) {
+    if (!specifier.startsWith(".")) {
+        return null;
+    }
+    return normalizeResolvedModuleBase(path.resolve(path.dirname(fromFile), specifier));
+}
+function normalizeResolvedModuleBase(filePath) {
+    let normalized = path.resolve(filePath);
+    for (const extension of RESOLVABLE_EXTENSIONS) {
+        if (normalized.endsWith(extension)) {
+            normalized = normalized.slice(0, -extension.length);
+            break;
+        }
+    }
+    if (normalized.endsWith(`${path.sep}index`)) {
+        normalized = normalized.slice(0, -"index".length - 1);
+    }
+    return normalized.toLowerCase();
+}
+function readSmallTextFile(file) {
+    try {
+        const stat = fs.statSync(file);
+        if (stat.size > MAX_FILE_BYTES) {
+            return null;
+        }
+        return fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+function emptyImpact(sourceFileCount = 0, existingSourceFileCount = 0) {
+    return {
+        sourceFileCount,
+        existingSourceFileCount,
+        importingFileCount: 0,
+        importStatementCount: 0,
+        barrelExportCount: 0,
+        scannedFileCount: 0,
+        truncated: false
+    };
+}