dependency-radar 0.1.1 → 0.2.0

package/dist/runners/importGraphRunner.js

@@ -0,0 +1,172 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runImportGraph = runImportGraph;
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const module_1 = require("module");
+const utils_1 = require("../utils");
+const IGNORED_DIRS = new Set(['node_modules', 'dist', 'build', 'coverage', '.dependency-radar']);
+const SOURCE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
+async function runImportGraph(projectPath, tempDir) {
+    const targetFile = path_1.default.join(tempDir, 'import-graph.json');
+    try {
+        const srcPath = path_1.default.join(projectPath, 'src');
+        const hasSrc = await (0, utils_1.pathExists)(srcPath);
+        const entry = hasSrc ? srcPath : projectPath;
+        const files = await collectSourceFiles(entry);
+        const fileGraph = {};
+        const packageGraph = {};
+        const unresolvedImports = [];
+        for (const file of files) {
+            const rel = normalizePath(projectPath, file);
+            const content = await promises_1.default.readFile(file, 'utf8');
+            const imports = extractImports(content);
+            const resolved = await resolveImports(imports, path_1.default.dirname(file), projectPath);
+            fileGraph[rel] = resolved.files;
+            packageGraph[rel] = resolved.packages;
+            unresolvedImports.push(...resolved.unresolved.map((spec) => ({ importer: rel, specifier: spec })));
+        }
+        const output = { files: fileGraph, packages: packageGraph, unresolvedImports };
+        await (0, utils_1.writeJsonFile)(targetFile, output);
+        return { ok: true, data: output, file: targetFile };
+    }
+    catch (err) {
+        await (0, utils_1.writeJsonFile)(targetFile, { error: String(err) });
+        return { ok: false, error: `import graph failed: ${String(err)}`, file: targetFile };
+    }
+}
+async function collectSourceFiles(rootDir) {
+    const files = [];
+    async function walk(current) {
+        const entries = await promises_1.default.readdir(current, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name.startsWith('.'))
+                continue;
+            const fullPath = path_1.default.join(current, entry.name);
+            if (entry.isDirectory()) {
+                if (IGNORED_DIRS.has(entry.name))
+                    continue;
+                await walk(fullPath);
+            }
+            else if (entry.isFile()) {
+                if (SOURCE_EXTENSIONS.includes(path_1.default.extname(entry.name))) {
+                    files.push(fullPath);
+                }
+            }
+        }
+    }
+    await walk(rootDir);
+    return files;
+}
+function extractImports(content) {
+    const matches = new Set();
+    const patterns = [
+        /\bimport\s+(?:[^'"]+from\s+)?['"]([^'"]+)['"]/g,
+        /\bexport\s+(?:[^'"]+from\s+)?['"]([^'"]+)['"]/g,
+        /\brequire\(\s*['"]([^'"]+)['"]\s*\)/g,
+        /\bimport\(\s*['"]([^'"]+)['"]\s*\)/g
+    ];
+    for (const pattern of patterns) {
+        let match;
+        while ((match = pattern.exec(content)) !== null) {
+            if (match[1])
+                matches.add(match[1]);
+        }
+    }
+    return Array.from(matches);
+}
+async function resolveImports(specifiers, fileDir, projectPath) {
+    const resolvedFiles = [];
+    const resolvedPackages = [];
+    const unresolved = [];
+    for (const spec of specifiers) {
+        if (isBuiltinModule(spec))
+            continue;
+        if (spec.startsWith('.') || spec.startsWith('/')) {
+            const target = await resolveFileTarget(spec, fileDir, projectPath);
+            if (target) {
+                resolvedFiles.push(target);
+            }
+            else {
+                unresolved.push(spec);
+            }
+        }
+        else {
+            resolvedPackages.push(toPackageName(spec));
+        }
+    }
+    return {
+        files: uniqSorted(resolvedFiles),
+        packages: uniqSorted(resolvedPackages),
+        unresolved: uniqSorted(unresolved)
+    };
+}
+async function resolveFileTarget(spec, fileDir, projectPath) {
+    const base = spec.startsWith('/')
+        ? path_1.default.resolve(projectPath, `.${spec}`)
+        : path_1.default.resolve(fileDir, spec);
+    const direct = await resolveFile(base);
+    if (direct)
+        return normalizePath(projectPath, direct);
+    return undefined;
+}
+async function resolveFile(basePath) {
+    if (await isFile(basePath))
+        return basePath;
+    for (const ext of SOURCE_EXTENSIONS) {
+        const candidate = `${basePath}${ext}`;
+        if (await isFile(candidate))
+            return candidate;
+    }
+    if (await isDir(basePath)) {
+        for (const ext of SOURCE_EXTENSIONS) {
+            const candidate = path_1.default.join(basePath, `index${ext}`);
+            if (await isFile(candidate))
+                return candidate;
+        }
+    }
+    return undefined;
+}
+async function isFile(target) {
+    try {
+        const stat = await promises_1.default.stat(target);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function isDir(target) {
+    try {
+        const stat = await promises_1.default.stat(target);
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function toPackageName(spec) {
+    if (spec.startsWith('@')) {
+        const parts = spec.split('/');
+        return parts.slice(0, 2).join('/');
+    }
+    return spec.split('/')[0];
+}
+function normalizePath(baseDir, filePath) {
+    const rel = path_1.default.relative(baseDir, filePath);
+    return rel.split(path_1.default.sep).join('/');
+}
+const BUILTIN_MODULES = new Set(module_1.builtinModules.flatMap((mod) => (mod.startsWith('node:') ? [mod, mod.slice(5)] : [mod])));
+function isBuiltinModule(spec) {
+    const normalized = spec.startsWith('node:') ? spec.slice(5) : spec;
+    if (BUILTIN_MODULES.has(spec) || BUILTIN_MODULES.has(normalized))
+        return true;
+    const root = normalized.split('/')[0];
+    return BUILTIN_MODULES.has(root);
+}
+function uniqSorted(values) {
+    return Array.from(new Set(values)).sort();
+}

package/dist/utils.js

@@ -138,11 +138,27 @@ async function readLicenseFromPackageJson(pkgName, projectPath) {
         const pkgRaw = await promises_1.default.readFile(pkgJsonPath, 'utf8');
         const pkg = JSON.parse(pkgRaw);
         const license = pkg.license || (Array.isArray(pkg.licenses) ? pkg.licenses.map((l) => (typeof l === 'string' ? l : l === null || l === void 0 ? void 0 : l.type)).filter(Boolean).join(' OR ') : undefined);
-        if (!license)
+        const licenseFile = await findLicenseFile(path_1.default.dirname(pkgJsonPath));
+        if (!license && !licenseFile)
             return undefined;
-        return { license, licenseFile: pkgJsonPath };
+        return { license, licenseFile };
     }
     catch (err) {
         return undefined;
     }
 }
+async function findLicenseFile(dir) {
+    try {
+        const entries = await promises_1.default.readdir(dir, { withFileTypes: true });
+        const fileNames = entries.filter((e) => e.isFile()).map((e) => e.name);
+        const patterns = [/^licen[cs]e(\.|$)/, /^copying(\.|$)/, /^notice(\.|$)/];
+        const match = fileNames.find((name) => {
+            const lower = name.toLowerCase();
+            return patterns.some((pattern) => pattern.test(lower));
+        });
+        return match ? path_1.default.join(dir, match) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dependency-radar",
-  "version": "0.1.1",
-  "description": "Local-first dependency analysis tool that generates a single HTML report showing risk, size, usage, and structure of your project’s dependencies.",
+  "version": "0.2.0",
+  "description": "Local-first dependency analysis tool that generates a single HTML report showing risk, size, usage, and structure of your project's dependencies.",
   "main": "dist/index.js",
   "bin": {
     "dependency-radar": "dist/cli.js"
@@ -10,7 +10,10 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsc",
+    "dev:report": "cd report-ui && npx vite",
+    "build:report-ui": "cd report-ui && npx vite build",
+    "build:report": "npm run build:report-ui && npx ts-node scripts/build-report.ts",
+    "build": "npm run build:report && tsc",
     "dev": "ts-node src/cli.ts scan",
     "scan": "node dist/cli.js scan",
     "prepublishOnly": "npm run build",
@@ -19,7 +22,7 @@
   "author": " ",
   "license": "MIT",
   "engines": {
-    "node": ">=18"
+    "node": ">=14.14.0"
   },
   "repository": {
     "type": "git",
@@ -43,14 +46,11 @@
     "node",
     "html"
   ],
-  "dependencies": {
-    "depcheck": "^1.4.7",
-    "license-checker": "^25.0.1",
-    "madge": "^8.0.0"
-  },
   "devDependencies": {
     "@types/node": "^20.11.30",
+    "terser": "^5.27.0",
     "ts-node": "^10.9.2",
-    "typescript": "^5.4.3"
+    "typescript": "^5.4.3",
+    "vite": "^5.4.0"
   }
 }