@zhaofx/deplens 1.0.0

package/bin/config.js

@@ -0,0 +1,5 @@
+export const port = 3456; // 服务端口
+
+export const packageManagers = ['npm', 'yarn', 'pnpm']; // 支持的包管理器
+
+

package/bin/diffView.js

@@ -0,0 +1,304 @@
+#!/usr/bin/env node
+import fs from 'fs-extra';
+import path from 'path';
+import yaml from 'yaml';
+import polka from 'polka';
+import open from 'open';
+import { fileURLToPath } from 'url';
+import { promisify } from 'util';
+import { glob } from 'glob';
+import * as parser from '@babel/parser';
+import traverseModule from '@babel/traverse';
+import { execSync } from 'node:child_process';
+
+const traverse = traverseModule.default || traverseModule;
+const st = promisify(fs.stat);
+const readDir = promisify(fs.readdir);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// 1. 获取物理体积 (不变)
+async function getDirSize(dirPath) {
+  let size = 0;
+  try {
+    const files = await readDir(dirPath);
+    for (const file of files) {
+      const filePath = path.join(dirPath, file);
+      const stats = await st(filePath);
+      if (stats.isDirectory()) {
+        size += await getDirSize(filePath);
+      } else {
+        size += stats.size;
+      }
+    }
+  } catch (err) { }
+  return size;
+}
+
+/**
+ * 获取当前环境的版本信息
+ */
+function getEnvInfo() {
+  try {
+    const nodeVersion = process.version; // 直接从 process 获取
+    const npmVersion = execSync('npm -v').toString().trim();
+
+    return {
+      node: nodeVersion,
+      npm: npmVersion,
+      platform: process.platform,
+      arch: process.arch
+    };
+  } catch (e) {
+    console.error("无法获取版本信息:", e);
+    return { node: process.version, npm: "unknown" };
+  }
+}
+
+function formatSize(bytes) {
+  if (bytes === 0 || !bytes) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+
+// 2. AST 扫描 (不变)
+async function scanSourceImports(rootDir) {
+  const importsMap = {};
+  console.log('正在进行 AST 源码扫描...');
+  const files = await glob('src/**/*.{js,ts,jsx,tsx}', { cwd: rootDir, absolute: true });
+  for (const file of files) {
+    try {
+      const code = await fs.readFile(file, 'utf8');
+      const ast = parser.parse(code, { sourceType: 'module', plugins: ['typescript', 'jsx', 'decorators-legacy'] });
+      const relPath = path.relative(rootDir, file);
+      traverse(ast, {
+        ImportDeclaration({ node }) {
+          if (!node.source.value.startsWith('.')) {
+            const parts = node.source.value.split('/');
+            const pkgName = node.source.value.startsWith('@') ? `${parts[0]}/${parts[1]}` : parts[0];
+            if (!importsMap[pkgName]) importsMap[pkgName] = [];
+            if (!importsMap[pkgName].includes(relPath)) importsMap[pkgName].push(relPath);
+          }
+        }
+      });
+    } catch (err) { }
+  }
+  return importsMap;
+}
+
+function parsePnpmKey(key) {
+  const noSlash = key.startsWith('/') ? key.slice(1) : key;
+  const parts = noSlash.split('@');
+  let name, versionStr;
+  if (noSlash.startsWith('@')) {
+    name = '@' + parts[1];
+    versionStr = parts.slice(2).join('@');
+  } else {
+    name = parts[0];
+    versionStr = parts.slice(1).join('@');
+  }
+  return { name, version: versionStr.split('(')[0] };
+}
+
+async function start() {
+  const rootDir = process.cwd();
+  const lockPath = path.join(rootDir, 'pnpm-lock.yaml');
+  const pkgPath = path.join(rootDir, 'package.json');
+  const pnpmStorePath = path.join(rootDir, 'node_modules/.pnpm');
+
+  if (!fs.existsSync(lockPath) || !fs.existsSync(pkgPath)) {
+    console.error('❌ 错误: 未发现 pnpm-lock.yaml 或 package.json');
+    process.exit(1);
+  }
+
+  const pkgData = fs.readJsonSync(pkgPath);
+  const rootDeps = { ...(pkgData.dependencies || {}), ...(pkgData.devDependencies || {}) };
+  const declaredDeps = new Set(Object.keys(rootDeps));
+
+  const realImports = await scanSourceImports(rootDir);
+  const lockData = yaml.parse(fs.readFileSync(lockPath, 'utf8'));
+  const snapshots = lockData.snapshots || lockData.packages || {};
+
+  console.log('正在解析 Lockfile 并计算磁盘体积...');
+
+  // 3. 将所有包缓存，方便构建树时快速查找
+  const pkgCache = {};
+  for (const key of Object.keys(snapshots)) {
+    const { name, version } = parsePnpmKey(key);
+    const pnpmName = name.replace(/\//g, '+');
+    const possiblePaths = [
+      path.join(pnpmStorePath, `${pnpmName}@${version}`, 'node_modules', name),
+      path.join(pnpmStorePath, `${pnpmName}@${version.split('_')[0]}`, 'node_modules', name)
+    ];
+
+    let size = 0;
+    for (const p of possiblePaths) {
+      if (fs.existsSync(p)) { size = await getDirSize(p); break; }
+    }
+
+    pkgCache[`${name}@${version}`] = {
+      name, version,
+      snapshot: snapshots[key],
+      size: size > 0 ? size : 1024,
+      isConflict: false // 简写
+    };
+  }
+
+  // 4. 【核心新增】递归构建嵌套依赖树
+  function buildDependencyTree(depsObj, visited = new Set()) {
+    const children = [];
+    for (const [depName, depVerReq] of Object.entries(depsObj)) {
+      // 模糊匹配：尝试找精确版本，找不到就取同名包的第一个
+      let match = pkgCache[`${depName}@${depVerReq}`] || Object.values(pkgCache).find(p => p.name === depName);
+      if (!match) continue;
+
+      const nodeKey = `${match.name}@${match.version}`;
+      // 防止循环依赖死循环
+      if (visited.has(nodeKey)) continue;
+
+      const newVisited = new Set(visited);
+      newVisited.add(nodeKey);
+
+      const subDeps = match.snapshot.dependencies || {};
+      const childNodes = buildDependencyTree(subDeps, newVisited);
+
+      const node = {
+        name: match.name,
+        version: match.version,
+        originalSize: match.size,
+        formattedSize: formatSize(match.size)
+      };
+
+      if (childNodes.length > 0) {
+        // 如果有子依赖，则当前包本身的代码作为 "自身(Self)" 节点展示
+        node.children = [
+          {
+            name: `${match.name} (自身)`,
+            version: match.version,
+            size: match.size,
+            formattedSize: formatSize(match.size),
+            isSelf: true
+          },
+          ...childNodes
+        ];
+      } else {
+        node.size = match.size;
+      }
+      children.push(node);
+    }
+    return children;
+  }
+
+  const rootChildren = buildDependencyTree(rootDeps);
+
+  // 5. 挂载幽灵依赖 (源码中引入了，但未在 package.json 声明的)
+  for (const ghostName of Object.keys(realImports)) {
+    if (!declaredDeps.has(ghostName)) {
+      const match = Object.values(pkgCache).find(p => p.name === ghostName);
+      if (match) {
+        rootChildren.push({
+          name: match.name,
+          version: match.version,
+          size: match.size,
+          formattedSize: formatSize(match.size),
+          isGhost: true,
+          ghostSources: realImports[ghostName]
+        });
+      }
+    }
+  }
+
+  const graphData = { name: pkgData.name || 'Project Root', children: rootChildren, environment: getEnvInfo() };
+
+
+
+  /**
+  * 尝试启动服务
+  * @param {number} port 初始端口
+  */
+  function startDepLens(currentPort, maxTries = 10, originalPort = currentPort) {
+    // 记录一个标记，防止在错误处理后再触发回调逻辑
+    const app = polka();
+    app.get('/data.js', (req, res) => {
+      res.setHeader('Content-Type', 'application/javascript');
+      return res.end(`window.CHART_DATA = ${JSON.stringify(graphData)};`);
+    });
+
+    // ico
+    app.get('/favicon.png', async (req, res) => {
+      res.setHeader('Content-Type', 'image/png');
+      const imgPath = path.join(__dirname, './assets/depLens.png'); // 图片实际路径
+      const img = await fs.readFile(imgPath); // 默认返回 Buffer
+
+      res.setHeader('Content-Type', 'image/png');
+      return res.end(img); // 直接发送 Buffer 数据
+    });
+
+    app.get('/', (req, res) => {
+      return res.end(fs.readFileSync(path.join(__dirname, 'template.html'), 'utf8'));
+    });
+
+    // 修复：增加一个简单的树平铺函数
+    function flattenTree(children, result = []) {
+      for (const child of children) {
+        // 只记录真实的包，跳过我们为了显示体积而伪造的 "(自身)" 节点
+        if (!child.isSelf) {
+          result.push({ name: child.name, version: child.version });
+        }
+        if (child.children) {
+          flattenTree(child.children, result);
+        }
+      }
+      return result;
+    }
+
+    app.get('/export', (req, res) => {
+      res.setHeader('Content-Type', 'application/json');
+
+      // 使用 flattenTree 处理构建好的 rootChildren
+      const snapshot = flattenTree(rootChildren);
+
+      // 去重：因为同一个包可能在树的不同层级出现多次
+      const uniqueSnapshot = Array.from(new Set(snapshot.map(s => `${s.name}@${s.version}`)))
+        .map(str => {
+          const [name, version] = str.split('@');
+          return { name, version };
+        });
+
+      return res.end(JSON.stringify(uniqueSnapshot));
+    });
+
+    const instance = app.listen(currentPort, (err) => {
+      if (err) return;
+
+      const address = instance.server.address();
+      const actualPort = address ? address.port : currentPort;
+
+      console.log(`🚀 DepLens 嵌套层级诊断已启动: http://localhost:${actualPort}`);
+
+      if (actualPort !== originalPort) {
+        console.log(`💡 注意：初始端口 ${originalPort} 被占用，已自动切换至 ${actualPort}`);
+      }
+
+      // 必须使用实际监听的端口打开
+      open(`http://localhost:${actualPort}`);
+    });
+
+    instance.server.on('error', (e) => {
+      if (e.code === 'EADDRINUSE') {
+        console.log(`端口 ${currentPort} 被占用，尝试使用下一个端口...`);
+        setTimeout(() => {
+          startDepLens(currentPort + 1, maxTries, originalPort);
+        }, 200);
+        return;
+      }
+      console.error(`❌ 服务器发生不可用错误: ${e.message}`);
+      process.exit(1);
+    })
+  }
+  const port = 3456; // 默认端口
+  startDepLens(port);
+}
+
+export default start;

package/bin/env-checker.js

@@ -0,0 +1,188 @@
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { packageManagers } from './config.js';
+import recordEnv from './env-recorder.js';
+import inquirer from 'inquirer'; // 建议安装：npm install inquirer
+/**
+ * 获取实时环境信息（用于对比）
+ */
+function getCurrentEnv() {
+  const getV = (cmd) => {
+    try { return execSync(cmd).toString().trim(); }
+    catch { return 'N/A'; }
+  };
+
+  return {
+    node: process.version,
+    npm: getV('npm -v'),
+    pnpm: getV('pnpm -v'),
+    yarn: getV('yarn -v'),
+    registry: getV('pnpm config get registry') || getV('npm config get registry'),
+    os: `${process.platform} (${process.arch})`,
+  };
+}
+
+/**
+ * depLens -check 核心功能
+ */
+export async function checkEnv() {
+  const historyPath = path.join(process.cwd(), '.deplens.history.json');
+
+  if (!fs.existsSync(historyPath)) {
+    console.warn('⚠️ 未发现 .deplens.history.json，请先运行 depLens -track 初始化项目标准。');
+    return;
+  }
+
+  const history = JSON.parse(fs.readFileSync(historyPath, 'utf8'));
+  const standard = history[history.length - 1]; // 取最后一次记录作为标准
+  const current = getCurrentEnv(); // 获取当前环境信息
+
+  const errors = [];
+  const warnings = [];
+
+  // 1. 强校验：Node 主版本 (Major Version)
+  if (standard.node.split('.')[0] !== current.node.split('.')[0]) {
+    errors.push(`Node 版本不匹配: 预期 ${standard.node}, 当前 ${current.node}`);
+  }
+
+  // 2. 强校验：包管理器 (Active Manager)
+  if (packageManagers.includes(standard.activeManager) && current[standard.activeManager] === 'N/A') {
+    errors.push(`缺失关键工具: 项目指定使用 ${standard.activeManager}，但本地未安装。`);
+  }
+
+  // 3. 强校验：镜像源 (防止 Lockfile 污染)
+  // 统一去掉末尾斜杠对比
+  const normalizeUrl = (url) => url.replace(/\/$/, '');
+  if (normalizeUrl(standard.registry.pnpm) !== normalizeUrl(current.registry)) {
+    errors.push(`Registry 不一致: \n   标准: ${standard.registry.pnpm}\n   当前: ${current.registry}`);
+  }
+
+  // 4. 弱校验：系统平台
+  if (standard.os !== current.os) {
+    warnings.push(`操作系统差异: 项目标准为 ${standard.os}, 当前为 ${current.os}`);
+  }
+
+  // --- 输出结果 ---
+  if (errors.length > 0) {
+    console.error('\n❌ 【DepLens 环境检查失败】');
+    errors.forEach(err => console.error(`   - ${err}`));
+    console.error('\n原因：环境不一致可能导致依赖安装失败、编译错误或 Lockfile 冲突。');
+    console.error('建议：请切换 Node 版本或修改 npm/pnpm registry。');
+
+    // 如果是 CI 环境或强制检查模式，阻断后续流程
+    if (process.env.CI || process.argv.includes('--strict')) {
+      process.exit(1);
+    }
+  } else {
+    console.log('✅ 【DepLens】环境检查通过：本地环境与项目标准一致。');
+    if (warnings.length > 0) {
+      warnings.forEach(w => console.log(`   ⚠️  注意: ${w}`));
+    }
+  }
+}
+
+
+
+/**
+ * depLens -install 核心实现
+ * 自动识别历史记录中的包管理器并执行安装
+ */
+export async function autoInstall() {
+  const historyPath = path.join(process.cwd(), '.deplens.history.json');
+
+  if (!fs.existsSync(historyPath)) {
+    console.error('❌ 错误: 未发现 .deplens.history.json。请先运行 depLens -track 初始化环境快照。');
+    process.exit(1);
+  }
+
+  const history = JSON.parse(fs.readFileSync(historyPath, 'utf8'));
+  // 获取最新的一条环境快照
+  const standard = history[history.length - 1];
+  const manager = standard.activeManager || 'npm';
+
+  console.log(`📦 检测到项目标准包管理器为: ${manager}`);
+  console.log(`🚀 正在准备执行: ${manager} install...`);
+
+  try {
+    // 1. 检查本地是否安装了该管理器
+    try {
+      execSync(`${manager} -v`, { stdio: 'ignore' });
+    } catch (e) {
+      console.warn(`⚠️  本地未检测到 ${manager}，尝试全局安装...`);
+      execSync(`npm install -g ${manager}`, { stdio: 'inherit' });
+    }
+
+    // 2. 检查 Registry 并在安装前提示
+    const currentRegistry = execSync(`${manager} config get registry`).toString().trim();
+    const standardRegistry = standard.registry[manager] || standard.registry.npm;
+
+    if (standardRegistry && standardRegistry !== 'N/A' && currentRegistry !== standardRegistry) {
+      console.log(`🌐 正在同步 Registry 镜像源至: ${standardRegistry}`);
+      execSync(`${manager} config set registry ${standardRegistry}`);
+    }
+
+    // 3. 执行安装
+    console.log(`\n🛠️  开始安装依赖...\n`);
+    execSync(`${manager} install`, { stdio: 'inherit' });
+
+    console.log(`\n✅ 依赖安装完成！`);
+  } catch (err) {
+    console.error(`\n❌ 安装过程中出现错误: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+
+/**
+ * 探测当前项目最匹配的包管理器
+ */
+function detectManager(rootDir) {
+  if (fs.existsSync(path.join(rootDir, 'pnpm-lock.yaml'))) return 'pnpm';
+  if (fs.existsSync(path.join(rootDir, 'package-lock.json'))) return 'npm';
+  if (fs.existsSync(path.join(rootDir, 'yarn.lock'))) return 'yarn';
+  return null;
+}
+
+/**
+ * depLens -init 实现
+ */
+export async function initProject() {
+  const rootDir = process.cwd();
+  const historyPath = path.join(rootDir, '.deplens.history.json');
+
+  console.log('🔍 DepLens 正在分析项目结构...');
+
+  // 1. 自动探测
+  const detected = detectManager(rootDir);
+
+  // 2. 交互式选择
+  const answers = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'manager',
+      message: '请确认该项目指定的标准包管理器（node:v16.9+ 内置Corepack,无需额外安装 pnpm/yarn ，低于v16.9版本请手动开启：corepack enable）：',
+      choices: [
+        { name: 'pnpm (推荐)', value: 'pnpm' },
+        { name: 'npm', value: 'npm' },
+        { name: 'yarn', value: 'yarn' },
+        { name: '不锁定 (不建议)', value: null }
+      ],
+      default: detected // 默认选中当前项目匹配的
+    },
+    {
+      type: 'confirm',
+      name: 'saveHistory',
+      message: '是否立即生成当前环境快照 (.deplens.history.json)?',
+      default: true
+    }
+  ]);
+
+  // 3. 执行 track 逻辑并生成文件
+  if (answers.saveHistory) {
+    await recordEnv(); // 记录当前环境快照
+    console.log('\n✅ 初始化成功！');
+    console.log(`📝 已创建标准快照，指定包管理器为: ${answers.manager || '未指定'}`);
+    console.log('💡 建议将 .deplens.history.json 提交至 Git 仓库以同步团队环境。');
+  }
+}

package/bin/env-recorder.js

@@ -0,0 +1,58 @@
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+function getSafeExec(cmd) {
+  try {
+    return execSync(cmd).toString().trim();
+  } catch (e) {
+    return 'N/A';
+  }
+}
+
+function recordEnv() {
+  // 1. 基础环境
+  const info = {
+    timestamp: new Date().toLocaleString(),
+    user: getSafeExec('git config user.name') || 'unknown',
+    os: `${process.platform} (${process.arch})`,
+    node: process.version,
+    // 2. 包管理器版本
+    npm: getSafeExec('npm -v'),
+    pnpm: getSafeExec('pnpm -v'),
+    yarn: getSafeExec('yarn -v'),
+    // 3. 当前生效的镜像源
+    registry: {
+      npm: getSafeExec('npm config get registry'),
+      pnpm: getSafeExec('pnpm config get registry'),
+      yarn: getSafeExec('yarn config get registry')
+    },
+    // 4. 锁定文件检测（判断实际安装方式）
+    lockfile: {
+      hasPackageLock: fs.existsSync(path.join(process.cwd(), 'package-lock.json')),
+      hasPnpmLock: fs.existsSync(path.join(process.cwd(), 'pnpm-lock.yaml')),
+      hasYarnLock: fs.existsSync(path.join(process.cwd(), 'yarn.lock'))
+    },
+    // 5. 核心依赖版本 (可选)
+    coreDeps: {}
+  };
+
+  // 自动识别当前项目使用的包管理器
+  info.activeManager = info.lockfile.hasPnpmLock ? 'pnpm' :
+    info.lockfile.hasYarnLock ? 'yarn' : 'npm';
+
+  const logPath = path.join(process.cwd(), '.deplens.history.json');
+
+  // 维护一个历史记录列表（保留最近10次安装记录）
+  let history = [];
+  if (fs.existsSync(logPath)) {
+    try { history = JSON.parse(fs.readFileSync(logPath)); } catch (e) { }
+  }
+  history.unshift(info);
+  fs.writeFileSync(logPath, JSON.stringify(history.slice(0, 10), null, 2));
+
+  return logPath;
+}
+
+
+export default recordEnv;

package/bin/index.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+
+import recordEnv from './env-recorder.js';
+import startServer from './diffView.js';
+import { packageManagers } from './config.js';
+import { checkEnv, autoInstall, initProject } from './env-checker.js';
+const args = process.argv.slice(2);
+const command = args[0];
+const packageJson = await import('../package.json', { with: { type: 'json' } });
+const version = packageJson.default.version;
+
+
+const tip = `
+用法: depLens [选项]
+
+选项:
+  -init       初始化项目标准
+  -track   记录当前 Node/npm/镜像 等环境信息
+  -view    启动本地 Web 服务查看依赖空间镜像
+  -check   检查当前环境是否符合记录的环境标准
+  -install   自动安装项目依赖
+  -package -p  查看支持的包管理器
+  -h       显示帮助信息
+  -v       查看版本
+`
+
+async function main() {
+  switch (command) {
+    // 初始化项目标准
+    case '-init':
+      await initProject();
+      break;
+
+    // 记录当前环境快照
+    case '-track':
+    case '-t':
+    case 'track':
+      console.log('🚀 正在采集当前环境快照...');
+      const logPath = recordEnv();
+      console.log(`✅ 环境已记录至: ${logPath}`);
+      break;
+
+    // 启动本地 Web 服务查看依赖空间镜像
+    case '-view':
+    case 'view':
+      console.log('🌐 正在启动 DepLens 可视化界面...');
+      await startServer(); // 启动你之前的 D3 渲染逻辑
+      break;
+
+    // 检查当前环境是否符合记录的环境标准
+    case '-check':
+      await checkEnv();
+      break;
+
+    // 自动安装项目依赖
+    case '-install':
+      await autoInstall();
+      break;
+
+    // 查看版本
+    case '--version':
+    case '-v':
+      console.log(`DepLens v${version}`);
+      break;
+
+    // 查看支持的包管理器
+    case '-package':
+    case '-p':
+      console.log('✅ DepLens 支持的包管理器:', packageManagers);
+      break;
+
+    // 显示帮助信息
+    case '-h':
+      console.log(tip);
+      process.exit(0);
+
+    // 默认显示帮助信息
+    default:
+      console.log(tip);
+      process.exit(0);
+  }
+}
+
+main();