impact-analysis 2.0.1 → 2.0.2

package/README.md

@@ -1,6 +1,14 @@
 # Impact Analysis
 
-Analyze the real impact of code changes in JavaScript, TypeScript, React, Vue, and Angular projects.
+[![npm version](https://badge.fury.io/js/impact-analysis.svg)](https://www.npmjs.com/package/impact-analysis)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.4-blue.svg)](https://www.typescriptlang.org/)
+
+> Analyze the real impact of code changes in JavaScript, TypeScript, React, Vue, and Angular projects.
+
+**Keywords:** `impact-analysis` · `dependency-graph` · `code-analysis` · `static-analysis` · `react` · `vue` · `angular` · `typescript` · `ast` · `ast-parser` · `code-impact` · `dependency-tracker` · `git-diff` · `change-analysis`
+
+---
 
 ## Features
 

package/dist/ai/explain.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.explainImpact = explainImpact;
+const generative_ai_1 = require("@google/generative-ai");
+async function explainImpact(results) {
+    if (!process.env.GEMINI_API_KEY) {
+        console.log('No GEMINI_API_KEY found. Skipping AI explanation.');
+        return null;
+    }
+    try {
+        const genAI = new generative_ai_1.GoogleGenerativeAI(process.env.GEMINI_API_KEY);
+        const model = genAI.getGenerativeModel({ model: 'gemini-3-flash-preview' });
+        const prompt = `Analyze these code changes and explain their impact:
+
+${JSON.stringify(results.map(r => ({
+            file: r.changedFile,
+            impactedFiles: r.impactedFiles.length,
+            risk: r.risk
+        })), null, 2)}
+
+Provide a brief summary of the overall risk and key concerns.`;
+        const result = await model.generateContent(prompt);
+        const response = await result.response;
+        return response.text();
+    }
+    catch (error) {
+        throw new Error(`AI explanation failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/dist/cache/graphCache.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadCache = loadCache;
+exports.saveCache = saveCache;
+const fs_1 = __importDefault(require("fs"));
+const CACHE_FILE = ".impact-analysis-cache.json";
+function loadCache() {
+    try {
+        if (!fs_1.default.existsSync(CACHE_FILE)) {
+            return null;
+        }
+        const data = JSON.parse(fs_1.default.readFileSync(CACHE_FILE, "utf-8"));
+        return {
+            imports: new Map(Object.entries(data.imports).map(([key, value]) => [key, new Set(value)])),
+            importedBy: new Map(Object.entries(data.importedBy).map(([key, value]) => [key, new Set(value)])),
+            componentUsage: new Map(Object.entries(data.componentUsage).map(([key, value]) => [key, new Set(value)]))
+        };
+    }
+    catch (error) {
+        console.warn('Cache file corrupted, rebuilding...');
+        return null;
+    }
+}
+function saveCache(data) {
+    try {
+        const serializable = {
+            imports: Object.fromEntries(Array.from(data.imports.entries()).map(([key, value]) => [key, Array.from(value)])),
+            importedBy: Object.fromEntries(Array.from(data.importedBy.entries()).map(([key, value]) => [key, Array.from(value)])),
+            componentUsage: Object.fromEntries(Array.from(data.componentUsage.entries()).map(([key, value]) => [key, Array.from(value)]))
+        };
+        fs_1.default.writeFileSync(CACHE_FILE, JSON.stringify(serializable, null, 2));
+    }
+    catch (error) {
+        console.warn('Failed to save cache:', error instanceof Error ? error.message : String(error));
+    }
+}

package/dist/cli.js

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+"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 });
+require("dotenv/config");
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const getChangedFiles_1 = require("./git/getChangedFiles");
+const scanRepo_1 = require("./scanner/scanRepo");
+const buildGraph_1 = require("./graph/buildGraph");
+const analyzer_1 = require("./core/analyzer");
+const html_generator_1 = require("./report/html-generator");
+const explain_1 = require("./ai/explain");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+async function main() {
+    const args = process.argv.slice(2);
+    const showHtml = args.includes('--html');
+    const useAI = args.includes('--ai');
+    const clearCache = args.includes('--clear-cache');
+    const baseBranch = args.find(arg => !arg.startsWith('--')) || 'main';
+    try {
+        if (clearCache) {
+            const fs = await Promise.resolve().then(() => __importStar(require('fs')));
+            if (fs.existsSync('.impact-analysis-cache.json')) {
+                fs.unlinkSync('.impact-analysis-cache.json');
+                console.log('Cache cleared.');
+            }
+        }
+        console.log('Scanning repository...');
+        const allFiles = await (0, scanRepo_1.scanRepo)();
+        console.log(`Building dependency graph from ${allFiles.length} files...`);
+        const graph = await (0, buildGraph_1.buildGraph)(allFiles);
+        console.log(`Getting changed files against ${baseBranch}...`);
+        const changedFiles = await (0, getChangedFiles_1.getChangedFiles)(baseBranch);
+        if (changedFiles.length === 0) {
+            console.log('No changed files found.');
+            return;
+        }
+        console.log(`Found ${changedFiles.length} changed files. Analyzing impact...`);
+        const dependencyMap = {};
+        graph.importedBy.forEach((importers, file) => {
+            dependencyMap[file] = Array.from(importers);
+        });
+        const results = (0, analyzer_1.analyzeImpact)(changedFiles, dependencyMap);
+        if (useAI) {
+            try {
+                console.log('Getting AI explanation...');
+                const explanation = await (0, explain_1.explainImpact)(results);
+                if (explanation) {
+                    results.aiExplanation = explanation;
+                }
+            }
+            catch (error) {
+                console.warn('AI explanation failed:', error instanceof Error ? error.message : String(error));
+            }
+        }
+        console.log('\n--- Impact Analysis Results ---\n');
+        results.forEach((result, index) => {
+            console.log(`${index + 1}. ${path_1.default.basename(result.changedFile)}`);
+            console.log(`   Risk: ${result.risk}`);
+            console.log(`   Impacted files: ${result.impactedFiles.length}`);
+            if (result.impactedFiles.length > 0) {
+                result.impactedFiles.slice(0, 5).forEach(file => {
+                    console.log(`     - ${path_1.default.basename(file)}`);
+                });
+                if (result.impactedFiles.length > 5) {
+                    console.log(`     ... and ${result.impactedFiles.length - 5} more`);
+                }
+            }
+            console.log('');
+        });
+        // Generate HTML by default
+        console.log('Generating HTML report...');
+        const htmlPath = (0, html_generator_1.generateHtmlReport)(results);
+        console.log(`Report saved: ${htmlPath}`);
+        if (showHtml) {
+            try {
+                // Use platform-specific command to open the file
+                const command = process.platform === 'win32'
+                    ? `start "" "${htmlPath}"`
+                    : process.platform === 'darwin'
+                        ? `open "${htmlPath}"`
+                        : `xdg-open "${htmlPath}"`;
+                await execAsync(command);
+                console.log(`Report opened in browser`);
+            }
+            catch (err) {
+                console.log(`Could not auto-open browser. Please open: ${htmlPath}`);
+            }
+        }
+        else {
+            console.log(`\nTo view the graphical report, run: impact-analysis --html`);
+        }
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+main();

package/dist/core/analyzer.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeImpact = analyzeImpact;
+function analyzeImpact(changedFiles, dependencyMap) {
+    return changedFiles.map(changed => {
+        const impacted = Object.entries(dependencyMap)
+            .filter(([, deps]) => deps.includes(changed))
+            .map(([file]) => file);
+        let risk = 'LOW';
+        if (impacted.length > 5)
+            risk = 'HIGH';
+        else if (impacted.length > 2)
+            risk = 'MEDIUM';
+        return {
+            changedFile: changed,
+            impactedFiles: impacted,
+            risk
+        };
+    });
+}

package/dist/git/getChangedFiles.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChangedFiles = getChangedFiles;
+const simple_git_1 = __importDefault(require("simple-git"));
+const path_1 = __importDefault(require("path"));
+async function getChangedFiles(base) {
+    try {
+        const git = (0, simple_git_1.default)();
+        const diff = await git.diff(["--name-only", base]);
+        return diff
+            .split("\n")
+            .filter(f => /\.(js|jsx|ts|tsx|vue)$/.test(f))
+            .map(f => path_1.default.resolve(process.cwd(), f));
+    }
+    catch (error) {
+        throw new Error(`Failed to get changed files. Make sure Git is installed and you're in a Git repository. Base branch: ${base}`);
+    }
+}

package/{src/graph/buildGraph.ts → dist/graph/buildGraph.js}

@@ -1,52 +1,56 @@
-import fs from "fs";
-import path from "path";
-import { extractImports } from "../parser/parseJS";
-import { parseVue } from "../parser/parseVue";
-import { DependencyGraph } from "./types";
-import { loadCache, saveCache } from "../cache/graphCache";
-
-function resolveImportPath(importPath: string, fromFile: string, allFiles: string[]): string | null {
-    if (
-        (!importPath.startsWith('.') && !importPath.startsWith('/') && 
-         !importPath.startsWith('~') && !importPath.startsWith('@') && 
-         !importPath.startsWith('#')) ||
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildGraph = buildGraph;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const parseJS_1 = require("../parser/parseJS");
+const parseVue_1 = require("../parser/parseVue");
+const graphCache_1 = require("../cache/graphCache");
+function resolveImportPath(importPath, fromFile, allFiles) {
+    if ((!importPath.startsWith('.') && !importPath.startsWith('/') &&
+        !importPath.startsWith('~') && !importPath.startsWith('@') &&
+        !importPath.startsWith('#')) ||
         importPath.startsWith('virtual:') ||
         importPath.startsWith('~icons/') ||
         importPath.startsWith('unplugin-') ||
-        /\.(css|scss|sass|less|styl|stylus|png|jpg|jpeg|gif|svg|woff|woff2|ttf|eot)$/.test(importPath)
-    ) {
+        /\.(css|scss|sass|less|styl|stylus|png|jpg|jpeg|gif|svg|woff|woff2|ttf|eot)$/.test(importPath)) {
         return null;
     }
-
-    const baseDir = path.dirname(fromFile);
+    const baseDir = path_1.default.dirname(fromFile);
     const projectRoot = process.cwd();
     const extensions = ['.vue', '.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs', ''];
     const indexFiles = ['/index.vue', '/index.js', '/index.ts', '/index.jsx', '/index.tsx', '/index.mjs'];
-
-    let resolvedBase: string | null = null;
-
+    let resolvedBase = null;
     // Handle various path alias patterns
     if (importPath.startsWith('~/') || importPath.startsWith('@/')) {
         // Common aliases: ~/ or @/ → project root
-        resolvedBase = path.join(projectRoot, importPath.substring(2));
-    } else if (importPath.startsWith('#')) {
+        resolvedBase = path_1.default.join(projectRoot, importPath.substring(2));
+    }
+    else if (importPath.startsWith('#')) {
         // Nuxt 3 aliases: #app, #imports, #components
         // Map to common locations
         if (importPath.startsWith('#app') || importPath.startsWith('#imports')) {
             return null; // Skip Nuxt internals
         }
         if (importPath.startsWith('#components/')) {
-            resolvedBase = path.join(projectRoot, 'components', importPath.substring(12));
-        } else {
+            resolvedBase = path_1.default.join(projectRoot, 'components', importPath.substring(12));
+        }
+        else {
             return null;
         }
-    } else if (importPath.startsWith('/')) {
+    }
+    else if (importPath.startsWith('/')) {
         // Absolute path from root
-        resolvedBase = path.join(projectRoot, importPath.substring(1));
-    } else if (importPath.startsWith('.')) {
+        resolvedBase = path_1.default.join(projectRoot, importPath.substring(1));
+    }
+    else if (importPath.startsWith('.')) {
         // Relative path
-        resolvedBase = path.join(baseDir, importPath);
-    } else {
+        resolvedBase = path_1.default.join(baseDir, importPath);
+    }
+    else {
         // Could be a tsconfig path alias (e.g., @components/...)
         // Try common patterns
         const aliasPatterns = [
@@ -56,63 +60,49 @@ function resolveImportPath(importPath: string, fromFile: string, allFiles: strin
             ['@src/', 'src/'],
             ['@/', ''],
         ];
-        
         for (const [alias, replacement] of aliasPatterns) {
             if (importPath.startsWith(alias)) {
-                resolvedBase = path.join(projectRoot, importPath.replace(alias, replacement));
+                resolvedBase = path_1.default.join(projectRoot, importPath.replace(alias, replacement));
                 break;
             }
         }
-        
         if (!resolvedBase) {
             return null; // Likely an external package
         }
     }
-
     // Normalize path separators
-    resolvedBase = path.normalize(resolvedBase);
-
+    resolvedBase = path_1.default.normalize(resolvedBase);
     const hasExtension = extensions.some(ext => ext && importPath.endsWith(ext));
-
     for (const ext of extensions) {
         const withExt = hasExtension ? resolvedBase : resolvedBase + ext;
-        
         if (allFiles.includes(withExt)) {
             return withExt;
         }
     }
-
     for (const indexFile of indexFiles) {
         const resolved = resolvedBase + indexFile;
         if (allFiles.includes(resolved)) {
             return resolved;
         }
     }
-
     return null;
 }
-
-export async function buildGraph(files: string[]): Promise<DependencyGraph> {
-    const cached = loadCache();
+async function buildGraph(files) {
+    const cached = (0, graphCache_1.loadCache)();
     if (cached) {
         console.log('Using cached dependency graph...');
         return cached;
     }
-
-    const graph: DependencyGraph = {
+    const graph = {
         imports: new Map(),
         importedBy: new Map(),
         componentUsage: new Map()
     };
-
     let filesProcessed = 0;
-
     for (const file of files) {
-        const code = fs.readFileSync(file, "utf-8");
-
+        const code = fs_1.default.readFileSync(file, "utf-8");
         if (file.endsWith(".vue")) {
-            const { imports, components } = parseVue(code);
-
+            const { imports, components } = (0, parseVue_1.parseVue)(code);
             imports.forEach(imp => {
                 const resolved = resolveImportPath(imp, file, files);
                 if (resolved) {
@@ -120,16 +110,12 @@ export async function buildGraph(files: string[]): Promise<DependencyGraph> {
                     graph.importedBy.set(resolved, (graph.importedBy.get(resolved) || new Set()).add(file));
                 }
             });
-
             components.forEach(component => {
-                graph.componentUsage.set(
-                    component,
-                    (graph.componentUsage.get(component) || new Set()).add(file)
-                );
+                graph.componentUsage.set(component, (graph.componentUsage.get(component) || new Set()).add(file));
             });
-        } else {
-            const imports = extractImports(code);
-
+        }
+        else {
+            const imports = (0, parseJS_1.extractImports)(code);
             imports.forEach(imp => {
                 const resolved = resolveImportPath(imp, file, files);
                 if (resolved) {
@@ -138,14 +124,9 @@ export async function buildGraph(files: string[]): Promise<DependencyGraph> {
                 }
             });
         }
-
         filesProcessed++;
     }
-
     console.log(`Dependency graph built: ${graph.importedBy.size} files with dependencies`);
-    
-    saveCache(graph);
-    
+    (0, graphCache_1.saveCache)(graph);
     return graph;
 }
-

package/dist/graph/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/parser/parseJS.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractImports = extractImports;
+const parser_1 = require("@babel/parser");
+const traverse_1 = __importDefault(require("@babel/traverse"));
+function extractImports(code) {
+    const imports = [];
+    try {
+        const ast = (0, parser_1.parse)(code, {
+            sourceType: "unambiguous",
+            plugins: [
+                "typescript",
+                "jsx",
+                "decorators-legacy",
+                "classProperties",
+                "dynamicImport",
+                "importMeta",
+                "topLevelAwait",
+                "classStaticBlock",
+                "optionalChaining",
+                "nullishCoalescingOperator"
+            ],
+            errorRecovery: true
+        });
+        (0, traverse_1.default)(ast, {
+            // Static imports: import x from 'module'
+            ImportDeclaration(path) {
+                imports.push(path.node.source.value);
+            },
+            // Dynamic imports: import('module')
+            Import(path) {
+                const parent = path.parent;
+                if (parent.type === 'CallExpression' && parent.arguments[0]) {
+                    const arg = parent.arguments[0];
+                    if (arg.type === 'StringLiteral') {
+                        imports.push(arg.value);
+                    }
+                }
+            },
+            // Export from: export { x } from 'module'
+            ExportNamedDeclaration(path) {
+                if (path.node.source) {
+                    imports.push(path.node.source.value);
+                }
+            },
+            // Export all: export * from 'module'
+            ExportAllDeclaration(path) {
+                imports.push(path.node.source.value);
+            },
+            // CommonJS require: const x = require('module')
+            CallExpression(path) {
+                if (path.node.callee.type === 'Identifier' &&
+                    path.node.callee.name === 'require' &&
+                    path.node.arguments[0] &&
+                    path.node.arguments[0].type === 'StringLiteral') {
+                    imports.push(path.node.arguments[0].value);
+                }
+            }
+        });
+    }
+    catch (error) {
+        // Silently skip files with parse errors
+        // Most errors are from node_modules or generated files
+    }
+    // Remove duplicates
+    return [...new Set(imports)];
+}

package/dist/parser/parseVue.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVue = parseVue;
+const compiler_sfc_1 = require("@vue/compiler-sfc");
+const parseJS_1 = require("./parseJS");
+const parseVueTemplate_1 = require("./parseVueTemplate");
+function parseVue(code) {
+    try {
+        const { descriptor } = (0, compiler_sfc_1.parse)(code);
+        const scriptContent = descriptor.script?.content || '';
+        const scriptSetupContent = descriptor.scriptSetup?.content || '';
+        const allScript = scriptContent + '\n' + scriptSetupContent;
+        return {
+            imports: allScript.trim() ? (0, parseJS_1.extractImports)(allScript) : [],
+            components: (0, parseVueTemplate_1.extractTemplateComponents)(code)
+        };
+    }
+    catch (error) {
+        return {
+            imports: [],
+            components: []
+        };
+    }
+}

package/dist/parser/parseVueTemplate.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTemplateComponents = extractTemplateComponents;
+const compiler_sfc_1 = require("@vue/compiler-sfc");
+function extractTemplateComponents(code) {
+    const { descriptor } = (0, compiler_sfc_1.parse)(code);
+    const template = descriptor.template?.content || "";
+    const componentRegex = /<([A-Z][\w-]*)/g;
+    const components = new Set();
+    let match;
+    while ((match = componentRegex.exec(template))) {
+        components.add(match[1]);
+    }
+    return Array.from(components);
+}

package/{src/report/html-generator.ts → dist/report/html-generator.js}

@@ -1,6 +1,11 @@
-import fs from 'fs';
-import path from 'path';
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateHtmlReport = generateHtmlReport;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
 const HTML_TEMPLATE = `<!DOCTYPE html>
 <html>
 <head>
@@ -324,20 +329,13 @@ const HTML_TEMPLATE = `<!DOCTYPE html>
 </script>
 </body>
 </html>`;
-
-export function generateHtmlReport(data: any) {
-  const outDir = path.resolve('.impact-analysis');
-  const jsonPath = path.join(outDir, 'impact.json');
-  const htmlPath = path.join(outDir, 'report.html');
-
-  fs.mkdirSync(outDir, { recursive: true });
-  fs.writeFileSync(jsonPath, JSON.stringify(data, null, 2));
-
-  const finalHtml = HTML_TEMPLATE.replace(
-    '__IMPACT_DATA__',
-    JSON.stringify(data)
-  );
-
-  fs.writeFileSync(htmlPath, finalHtml);
-  return htmlPath;
+function generateHtmlReport(data) {
+    const outDir = path_1.default.resolve('.impact-analysis');
+    const jsonPath = path_1.default.join(outDir, 'impact.json');
+    const htmlPath = path_1.default.join(outDir, 'report.html');
+    fs_1.default.mkdirSync(outDir, { recursive: true });
+    fs_1.default.writeFileSync(jsonPath, JSON.stringify(data, null, 2));
+    const finalHtml = HTML_TEMPLATE.replace('__IMPACT_DATA__', JSON.stringify(data));
+    fs_1.default.writeFileSync(htmlPath, finalHtml);
+    return htmlPath;
 }

package/dist/scanner/scanRepo.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanRepo = scanRepo;
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const path_1 = __importDefault(require("path"));
+async function scanRepo() {
+    try {
+        const files = await (0, fast_glob_1.default)("**/*.{js,jsx,ts,tsx,vue}", {
+            ignore: [
+                "node_modules/**",
+                "dist/**",
+                "build/**",
+                "*.min.js",
+                "**/*.min.js",
+                ".next/**",
+                "coverage/**",
+                ".cache/**",
+                "out/**",
+                ".nuxt/**"
+            ]
+        });
+        return files.map(file => path_1.default.resolve(process.cwd(), file));
+    }
+    catch (error) {
+        throw new Error(`Failed to scan repository: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}