vibeclean 1.0.0

package/src/analyzers/deadcode.js

@@ -0,0 +1,294 @@
+import path from "node:path";
+import { severityFromScore, scoreFromRatio } from "./utils.js";
+
+const EXTENSIONS = [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".vue", ".svelte"];
+
+function resolveRelativeImport(fromFile, specifier, existingFiles) {
+  const baseDir = path.dirname(fromFile);
+  const direct = path.normalize(path.join(baseDir, specifier));
+
+  if (existingFiles.has(direct)) {
+    return direct;
+  }
+
+  for (const ext of EXTENSIONS) {
+    if (existingFiles.has(`${direct}${ext}`)) {
+      return `${direct}${ext}`;
+    }
+  }
+
+  for (const ext of EXTENSIONS) {
+    if (existingFiles.has(path.join(direct, `index${ext}`))) {
+      return path.join(direct, `index${ext}`);
+    }
+  }
+
+  return null;
+}
+
+function extractRelativeImports(content) {
+  const imports = [];
+
+  for (const match of content.matchAll(/import\s+[^"'`]*?from\s+["'`]([^"'`]+)["'`]/g)) {
+    imports.push(match[1]);
+  }
+  for (const match of content.matchAll(/import\s+["'`]([^"'`]+)["'`]/g)) {
+    imports.push(match[1]);
+  }
+  for (const match of content.matchAll(/require\(\s*["'`]([^"'`]+)["'`]\s*\)/g)) {
+    imports.push(match[1]);
+  }
+
+  return imports.filter((item) => item.startsWith("."));
+}
+
+function extractImportUsage(content) {
+  const imports = [];
+
+  for (const match of content.matchAll(/import\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*(?:,\s*\{([^}]+)\})?\s+from\s+["'`]([^"'`]+)["'`]/g)) {
+    const names = (match[2] || "")
+      .split(",")
+      .map((item) => item.trim().split(/\s+as\s+/i)[0])
+      .filter(Boolean);
+    imports.push({ specifier: match[3], names, defaultImport: true, namespaceImport: false });
+  }
+
+  for (const match of content.matchAll(/import\s+\{([^}]+)\}\s+from\s+["'`]([^"'`]+)["'`]/g)) {
+    const names = match[1]
+      .split(",")
+      .map((item) => item.trim().split(/\s+as\s+/i)[0])
+      .filter(Boolean);
+    imports.push({ specifier: match[2], names, defaultImport: false, namespaceImport: false });
+  }
+
+  for (const match of content.matchAll(/import\s+\*\s+as\s+[A-Za-z_$][A-Za-z0-9_$]*\s+from\s+["'`]([^"'`]+)["'`]/g)) {
+    imports.push({ specifier: match[1], names: [], defaultImport: false, namespaceImport: true });
+  }
+
+  for (const match of content.matchAll(/const\s+[A-Za-z_$][A-Za-z0-9_$]*\s*=\s*require\(\s*["'`]([^"'`]+)["'`]\s*\)/g)) {
+    imports.push({ specifier: match[1], names: [], defaultImport: true, namespaceImport: false });
+  }
+
+  for (const match of content.matchAll(/const\s+\{([^}]+)\}\s*=\s*require\(\s*["'`]([^"'`]+)["'`]\s*\)/g)) {
+    const names = match[1]
+      .split(",")
+      .map((item) => item.trim().split(/\s*:\s*/)[0])
+      .filter(Boolean);
+    imports.push({ specifier: match[2], names, defaultImport: false, namespaceImport: false });
+  }
+
+  return imports;
+}
+
+function extractExports(content) {
+  const names = new Set();
+  let hasDefault = /\bexport\s+default\b/.test(content);
+
+  for (const match of content.matchAll(/export\s+(?:const|let|var|function|class)\s+([A-Za-z_$][A-Za-z0-9_$]*)/g)) {
+    names.add(match[1]);
+  }
+
+  for (const match of content.matchAll(/export\s*\{([^}]+)\}/g)) {
+    const parts = match[1]
+      .split(",")
+      .map((item) => item.trim())
+      .filter(Boolean);
+    for (const part of parts) {
+      const aliasMatch = part.match(/^([A-Za-z_$][A-Za-z0-9_$]*)(?:\s+as\s+([A-Za-z_$][A-Za-z0-9_$]*))?$/i);
+      if (!aliasMatch) {
+        continue;
+      }
+
+      const localName = aliasMatch[1];
+      const exportedName = aliasMatch[2] || localName;
+      if (exportedName === "default") {
+        hasDefault = true;
+      } else {
+        names.add(localName);
+      }
+    }
+  }
+
+  return {
+    named: [...names],
+    hasDefault
+  };
+}
+
+function isEntrypoint(relativePath) {
+  return (
+    /(^|\/)(index|main|app)\.(js|jsx|ts|tsx|mjs|cjs)$/.test(relativePath) ||
+    /(^|\/)(pages|routes)\//.test(relativePath)
+  );
+}
+
+function codeLineCount(content) {
+  const lines = content.split("\n");
+  let count = 0;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("//") || trimmed === "{" || trimmed === "}") {
+      continue;
+    }
+    count += 1;
+  }
+
+  return count;
+}
+
+function isReexportOnly(content) {
+  const lines = content
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean);
+
+  if (!lines.length) {
+    return false;
+  }
+
+  return lines.every((line) => /^export\s+(\*|\{)/.test(line));
+}
+
+export function analyzeDeadCode(files) {
+  const existingFiles = new Set(files.map((file) => file.relativePath));
+  const incomingRefs = new Map();
+  const exportsByFile = new Map();
+  const importUsageByFile = new Map();
+
+  for (const file of files) {
+    incomingRefs.set(file.relativePath, new Set());
+  }
+
+  for (const file of files) {
+    const imports = extractRelativeImports(file.content);
+    for (const specifier of imports) {
+      const resolved = resolveRelativeImport(file.relativePath, specifier, existingFiles);
+      if (!resolved || !incomingRefs.has(resolved)) {
+        continue;
+      }
+
+      incomingRefs.get(resolved).add(file.relativePath);
+    }
+
+    exportsByFile.set(file.relativePath, extractExports(file.content));
+
+    for (const importInfo of extractImportUsage(file.content)) {
+      const resolved = importInfo.specifier.startsWith(".")
+        ? resolveRelativeImport(file.relativePath, importInfo.specifier, existingFiles)
+        : null;
+
+      if (!resolved) {
+        continue;
+      }
+
+      if (!importUsageByFile.has(resolved)) {
+        importUsageByFile.set(resolved, {
+          named: new Set(),
+          defaultImport: false,
+          namespaceImport: false
+        });
+      }
+
+      const usage = importUsageByFile.get(resolved);
+      usage.defaultImport = usage.defaultImport || Boolean(importInfo.defaultImport);
+      usage.namespaceImport = usage.namespaceImport || Boolean(importInfo.namespaceImport);
+      for (const name of importInfo.names) {
+        usage.named.add(name);
+      }
+    }
+  }
+
+  const orphanFiles = [];
+  for (const file of files) {
+    const refs = incomingRefs.get(file.relativePath);
+    const inSrc = file.relativePath.startsWith("src/");
+
+    if (inSrc && refs && refs.size === 0 && !isEntrypoint(file.relativePath)) {
+      orphanFiles.push(file.relativePath);
+    }
+  }
+
+  const unusedExports = [];
+  for (const [filePath, exportInfo] of exportsByFile.entries()) {
+    if (!exportInfo.named.length && !exportInfo.hasDefault) {
+      continue;
+    }
+
+    const used = importUsageByFile.get(filePath) || {
+      named: new Set(),
+      defaultImport: false,
+      namespaceImport: false
+    };
+
+    for (const exportName of exportInfo.named) {
+      if (!used.named.has(exportName) && !used.namespaceImport && !isEntrypoint(filePath)) {
+        unusedExports.push({ file: filePath, name: exportName });
+      }
+    }
+
+    if (exportInfo.hasDefault && !used.defaultImport && !used.namespaceImport && !isEntrypoint(filePath)) {
+      unusedExports.push({ file: filePath, name: "default" });
+    }
+  }
+
+  const stubFiles = [];
+  for (const file of files) {
+    const lines = codeLineCount(file.content);
+    if (lines < 5 || isReexportOnly(file.content)) {
+      stubFiles.push({ file: file.relativePath, lines });
+    }
+  }
+
+  const findings = [];
+  if (orphanFiles.length) {
+    findings.push({
+      severity: orphanFiles.length > 5 ? "high" : "medium",
+      message: `${orphanFiles.length} orphan files are not imported anywhere.`,
+      files: orphanFiles.slice(0, 25)
+    });
+  }
+
+  if (unusedExports.length) {
+    findings.push({
+      severity: "medium",
+      message: `${unusedExports.length} exports are never imported.`,
+      files: unusedExports.map((item) => item.file).slice(0, 25)
+    });
+  }
+
+  if (stubFiles.length) {
+    findings.push({
+      severity: "low",
+      message: `${stubFiles.length} files look like stubs or thin re-export shells.`,
+      files: stubFiles.map((item) => item.file).slice(0, 25)
+    });
+  }
+
+  const signal = orphanFiles.length * 2 + unusedExports.length + stubFiles.length;
+  const score = Math.min(10, scoreFromRatio(signal / Math.max(files.length * 0.6, 1), 10));
+
+  return {
+    id: "deadcode",
+    title: "DEAD CODE",
+    score,
+    severity: severityFromScore(score),
+    totalIssues: orphanFiles.length + unusedExports.length + stubFiles.length,
+    summary:
+      findings.length > 0
+        ? `${findings.length} dead-code signals found.`
+        : "No major dead-code hotspots detected.",
+    metrics: {
+      orphanFiles,
+      unusedExports,
+      stubFiles
+    },
+    recommendations: [
+      "Delete or wire orphan files into active code paths.",
+      "Remove unused exports or consume them where needed.",
+      "Consolidate stub/re-export files where they do not add structure."
+    ],
+    findings
+  };
+}
+

package/src/analyzers/dependencies.js

@@ -0,0 +1,241 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { collectImportSpecifiers, packageRoot, severityFromScore, scoreFromRatio } from "./utils.js";
+
+const DUPLICATE_GROUPS = [
+  ["lodash", "underscore"],
+  ["moment", "dayjs"],
+  ["moment", "date-fns"],
+  ["express", "koa"],
+  ["express", "fastify"],
+  ["jest", "vitest"],
+  ["jest", "mocha"],
+  ["vitest", "mocha"]
+];
+
+const OUTDATED_PACKAGES = {
+  moment: "Consider migrating to dayjs or date-fns for lighter bundles.",
+  request: "request is deprecated. Prefer fetch or undici.",
+  lodash: "Consider lodash-es or native methods where possible."
+};
+
+const ESTIMATED_MB = {
+  lodash: 0.5,
+  moment: 0.6,
+  request: 0.3,
+  axios: 0.2,
+  express: 1.0,
+  jest: 1.7,
+  mocha: 0.8,
+  chalk: 0.08,
+  uuid: 0.05,
+  cors: 0.04,
+  dotenv: 0.03
+};
+
+const CLI_PACKAGE_ALIASES = {
+  jest: "jest",
+  vitest: "vitest",
+  mocha: "mocha",
+  eslint: "eslint",
+  prettier: "prettier",
+  tsc: "typescript",
+  vite: "vite",
+  webpack: "webpack",
+  rollup: "rollup",
+  nodemon: "nodemon",
+  ava: "ava",
+  nyc: "nyc",
+  "ts-node": "ts-node"
+};
+
+const CONFIG_FILE_HINTS = {
+  tailwindcss: ["tailwind.config.js", "tailwind.config.cjs", "tailwind.config.mjs"],
+  postcss: ["postcss.config.js", "postcss.config.cjs", "postcss.config.mjs"],
+  autoprefixer: ["postcss.config.js", "postcss.config.cjs", "postcss.config.mjs"],
+  "@babel/core": ["babel.config.js", ".babelrc", ".babelrc.json"],
+  eslint: [".eslintrc", ".eslintrc.json", ".eslintrc.js", "eslint.config.js"],
+  prettier: [".prettierrc", ".prettierrc.json", "prettier.config.js"],
+  jest: ["jest.config.js", "jest.config.cjs", "jest.config.mjs"],
+  vitest: ["vitest.config.js", "vitest.config.ts", "vite.config.js", "vite.config.ts"]
+};
+
+const SAFE_DEV_TOOLS = new Set([
+  "typescript",
+  "@types/node",
+  "@types/react",
+  "@types/react-dom",
+  "husky",
+  "lint-staged",
+  "rimraf",
+  "cross-env",
+  "npm-run-all",
+  "concurrently"
+]);
+
+async function exists(rootDir, relativeFile) {
+  try {
+    await fs.access(path.join(rootDir, relativeFile));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function parseScriptCommands(scripts = {}) {
+  const used = new Set();
+
+  for (const script of Object.values(scripts)) {
+    const firstCommand = script.split(/&&|\|\||;/)[0].trim();
+    const parts = firstCommand.split(/\s+/).filter(Boolean);
+    const token = parts[0] || "";
+    let normalized = token;
+
+    if (token === "npx") {
+      normalized = parts[1] || "";
+    } else if ((token === "pnpm" || token === "yarn" || token === "npm") && parts[1] === "run") {
+      normalized = parts[2] || "";
+    }
+
+    if (CLI_PACKAGE_ALIASES[normalized]) {
+      used.add(CLI_PACKAGE_ALIASES[normalized]);
+    }
+  }
+
+  return used;
+}
+
+export async function analyzeDependencies(files, context = {}) {
+  const packageJson = context.packageJson;
+  const rootDir = context.rootDir;
+
+  if (!packageJson) {
+    return {
+      id: "dependencies",
+      title: "DEPENDENCY ISSUES",
+      score: 0,
+      severity: "low",
+      totalIssues: 0,
+      summary: "No package.json found. Dependency analysis was skipped.",
+      metrics: {},
+      recommendations: ["Add a package.json if you want dependency auditing."],
+      findings: [],
+      skipped: true
+    };
+  }
+
+  const dependencies = packageJson.dependencies || {};
+  const devDependencies = packageJson.devDependencies || {};
+  const allDeps = [...Object.keys(dependencies), ...Object.keys(devDependencies)];
+
+  const importedPackages = new Set();
+  for (const file of files) {
+    for (const specifier of collectImportSpecifiers(file.content)) {
+      const root = packageRoot(specifier);
+      if (root) {
+        importedPackages.add(root);
+      }
+    }
+  }
+
+  const scriptUsedPackages = parseScriptCommands(packageJson.scripts || {});
+
+  const configHintUsed = new Set();
+  for (const [pkg, configFiles] of Object.entries(CONFIG_FILE_HINTS)) {
+    for (const configFile of configFiles) {
+      if (await exists(rootDir, configFile)) {
+        configHintUsed.add(pkg);
+        break;
+      }
+    }
+  }
+
+  const unused = [];
+  for (const dep of allDeps) {
+    const usedByImport = importedPackages.has(dep);
+    const usedByScript = scriptUsedPackages.has(dep);
+    const usedByConfig = configHintUsed.has(dep);
+    const safeTool = SAFE_DEV_TOOLS.has(dep) || dep.startsWith("@types/");
+
+    if (!usedByImport && !usedByScript && !usedByConfig && !safeTool) {
+      unused.push(dep);
+    }
+  }
+
+  const duplicates = [];
+  for (const group of DUPLICATE_GROUPS) {
+    const present = group.filter((name) => allDeps.includes(name));
+    if (present.length > 1) {
+      duplicates.push(present);
+    }
+  }
+
+  const outdated = [];
+  for (const dep of allDeps) {
+    if (OUTDATED_PACKAGES[dep]) {
+      outdated.push({ dep, note: OUTDATED_PACKAGES[dep] });
+    }
+  }
+
+  const estimatedSavingsMb = unused.reduce((sum, dep) => sum + (ESTIMATED_MB[dep] || 0.05), 0);
+
+  const findings = [];
+  if (unused.length) {
+    findings.push({
+      severity: unused.length >= 5 ? "high" : "medium",
+      message: `${unused.length} unused packages detected.`,
+      packages: unused.slice(0, 30)
+    });
+  }
+
+  if (duplicates.length) {
+    findings.push({
+      severity: "medium",
+      message: `${duplicates.length} duplicate functionality groups found.`,
+      packages: duplicates
+    });
+  }
+
+  if (outdated.length) {
+    findings.push({
+      severity: "medium",
+      message: `${outdated.length} outdated or heavy packages detected.`,
+      packages: outdated.map((item) => item.dep)
+    });
+  }
+
+  const score = Math.min(
+    10,
+    scoreFromRatio(
+      (unused.length + duplicates.length * 2 + outdated.length) / Math.max(allDeps.length * 0.5, 1),
+      10
+    )
+  );
+
+  return {
+    id: "dependencies",
+    title: "DEPENDENCY ISSUES",
+    score,
+    severity: severityFromScore(score),
+    totalIssues: unused.length + duplicates.length + outdated.length,
+    summary:
+      findings.length > 0
+        ? `${findings.length} dependency risk areas found.`
+        : "No major dependency bloat or overlap detected.",
+    metrics: {
+      dependencyCount: Object.keys(dependencies).length,
+      devDependencyCount: Object.keys(devDependencies).length,
+      unusedCount: unused.length,
+      duplicateGroups: duplicates,
+      outdated: outdated,
+      estimatedSavingsMb: Number(estimatedSavingsMb.toFixed(2))
+    },
+    recommendations: [
+      "Remove unused dependencies to reduce install time and attack surface.",
+      "Keep one package per concern where possible (date, test runner, web framework).",
+      "Replace deprecated packages with actively maintained alternatives."
+    ],
+    findings
+  };
+}
+