@codacy/analysis-runner 0.6.1 → 0.8.0

package/dist/index.js

@@ -34,15 +34,18 @@ __export(index_exports, {
   applyCodacyYamlExcludes: () => applyCodacyYamlExcludes,
   buildToolConfig: () => buildToolConfig,
   clearAdapters: () => clearAdapters,
+  computePatternSummary: () => computePatternSummary,
   configureApiToken: () => configureApiToken,
   createCodacyConfig: () => createCodacyConfig,
   createLogger: () => createLogger,
   detectLanguages: () => detectLanguages,
+  discover: () => discover,
   formatOutput: () => formatOutput,
   formatTextSummary: () => formatTextSummary,
   getAdapter: () => getAdapter,
   getRegisteredAdapters: () => getRegisteredAdapters,
   getRegisteredDescriptors: () => getRegisteredDescriptors,
+  initAutoConfig: () => initAutoConfig,
   initContainerConfig: () => initContainerConfig,
   initDefaultConfig: () => initDefaultConfig,
   initLocalConfig: () => initLocalConfig,
@@ -51,6 +54,7 @@ __export(index_exports, {
   listIgnoredFiles: () => listIgnoredFiles,
   listPrFiles: () => listPrFiles,
   listStagedFiles: () => listStagedFiles,
+  parseAutoFilters: () => parseAutoFilters,
   readCodacyConfig: () => readCodacyConfig,
   readCodacyYaml: () => readCodacyYaml,
   registerAdapter: () => registerAdapter,
@@ -192,6 +196,7 @@ function createCodacyConfig(params = {}) {
       source: params.source ?? "local",
       provider: params.provider ?? null,
       organization: params.organization ?? null,
+      autoFilters: params.autoFilters,
       repositoryId: params.repositoryId ?? null,
       repositoryName: params.repositoryName ?? null,
       createdAt: now,
@@ -460,6 +465,116 @@ async function runToolsParallel(tools, timeoutMs, concurrency, callbacks) {
   return results;
 }
 
+// src/summary.ts
+var NOISY_THRESHOLD = 500;
+var SEVERITY_ORDER = ["Error", "High", "Warning", "Info"];
+var SEVERITY_LABELS = {
+  Error: "CRITICAL",
+  High: "HIGH",
+  Warning: "WARNING",
+  Info: "MINOR"
+};
+var CATEGORY_ORDER = [
+  "Security",
+  "ErrorProne",
+  "Performance",
+  "BestPractice",
+  "UnusedCode",
+  "Compatibility",
+  "Complexity",
+  "Comprehensibility",
+  "CodeStyle",
+  "Documentation"
+];
+function formatCategoryName(category) {
+  return category.replace(/([a-z])([A-Z])/g, "$1 $2");
+}
+function computePatternSummary(issues, lookup) {
+  if (issues.length === 0) {
+    return {
+      groups: [],
+      totalIssues: 0,
+      totalPatterns: 0,
+      noisyPatternCount: 0,
+      noisyThreshold: NOISY_THRESHOLD
+    };
+  }
+  const accumMap = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    const key = `${issue.toolId}|${issue.severity}|${issue.category}|${issue.patternId}`;
+    let accum = accumMap.get(key);
+    if (!accum) {
+      accum = {
+        patternId: issue.patternId,
+        toolId: issue.toolId,
+        severity: issue.severity,
+        category: issue.category,
+        issueCount: 0,
+        files: /* @__PURE__ */ new Set()
+      };
+      accumMap.set(key, accum);
+    }
+    accum.issueCount++;
+    accum.files.add(issue.filePath);
+  }
+  const groupMap = /* @__PURE__ */ new Map();
+  for (const accum of accumMap.values()) {
+    const groupKey = `${accum.severity}|${accum.category}`;
+    let list = groupMap.get(groupKey);
+    if (!list) {
+      list = [];
+      groupMap.set(groupKey, list);
+    }
+    list.push(accum);
+  }
+  let totalPatterns = 0;
+  let noisyPatternCount = 0;
+  const groups = [];
+  for (const severity of SEVERITY_ORDER) {
+    for (const category of CATEGORY_ORDER) {
+      const accums = groupMap.get(`${severity}|${category}`);
+      if (!accums || accums.length === 0) continue;
+      accums.sort((a, b) => b.issueCount - a.issueCount);
+      let groupIssueCount = 0;
+      const patterns = [];
+      for (const acc of accums) {
+        const meta = lookup.get(`${acc.toolId}|${acc.patternId}`);
+        const noisy = acc.issueCount >= NOISY_THRESHOLD;
+        if (noisy) noisyPatternCount++;
+        totalPatterns++;
+        groupIssueCount += acc.issueCount;
+        patterns.push({
+          patternId: acc.patternId,
+          title: meta?.title ?? acc.patternId,
+          toolId: acc.toolId,
+          toolDisplayName: meta?.toolDisplayName ?? acc.toolId,
+          category,
+          severity,
+          issueCount: acc.issueCount,
+          fileCount: acc.files.size,
+          noisy
+        });
+      }
+      groups.push({
+        severity,
+        severityLabel: SEVERITY_LABELS[severity],
+        category,
+        categoryLabel: formatCategoryName(category),
+        patterns,
+        totalIssues: groupIssueCount,
+        totalPatterns: patterns.length
+      });
+    }
+  }
+  return {
+    groups,
+    totalIssues: issues.length,
+    totalPatterns,
+    noisyPatternCount,
+    noisyThreshold: NOISY_THRESHOLD
+  };
+}
+
 // src/analyze.ts
 var execFileAsync = (0, import_util.promisify)(import_child_process2.execFile);
 var nullLogger = {
@@ -831,6 +946,18 @@ async function analyze(options) {
   const allIssues = normalizeIssues(results.flatMap((r) => r.issues));
   const allErrors = results.flatMap((r) => r.errors);
   const allSummaries = results.map((r) => r.summary);
+  const patternLookup = /* @__PURE__ */ new Map();
+  for (const { adapter } of toolRuns) {
+    if (adapter.patternsMetadata) {
+      for (const entry of adapter.patternsMetadata) {
+        patternLookup.set(`${adapter.id}|${entry.id}`, {
+          title: entry.title,
+          toolDisplayName: adapter.displayName
+        });
+      }
+    }
+  }
+  const patternSummary = allIssues.length > 0 ? computePatternSummary(allIssues, patternLookup) : void 0;
   logger.info("Pipeline complete", {
     totalIssues: allIssues.length,
     totalErrors: allErrors.length,
@@ -843,7 +970,8 @@ async function analyze(options) {
     capability,
     allIssues,
     allErrors,
-    allSummaries
+    allSummaries,
+    patternSummary
   );
 }
 function makeToolContext(base, adapter, targetFiles) {
@@ -869,7 +997,7 @@ function resolveGitScope(repositoryRoot, scope) {
   const base = scope.diff === true ? void 0 : scope.diff;
   return listDiffFiles(repositoryRoot, base);
 }
-function buildResult(startedAt, repositoryRoot, mode, capability, issues, errors, toolResults) {
+function buildResult(startedAt, repositoryRoot, mode, capability, issues, errors, toolResults, patternSummary) {
   const completedAt = /* @__PURE__ */ new Date();
   return {
     metadata: {
@@ -882,7 +1010,8 @@ function buildResult(startedAt, repositoryRoot, mode, capability, issues, errors
     capability,
     issues,
     errors,
-    toolResults
+    toolResults,
+    ...patternSummary ? { patternSummary } : {}
   };
 }
 
@@ -1159,6 +1288,11 @@ function formatTextSummary(result, isInspect) {
       }
     }
   }
+  const patternSummaryText = formatPatternSummary(result.patternSummary);
+  if (patternSummaryText) {
+    lines.push("");
+    lines.push(patternSummaryText);
+  }
   return lines.join("\n");
 }
 var MAX_LINE_LENGTH = 100;
@@ -1241,23 +1375,801 @@ function colorSeverity(severity) {
       return `[${severity}]`;
   }
 }
+function severityColorFn(severity) {
+  switch (severity) {
+    case "Error":
+      return (s) => import_ansis.default.hex("#ff6347")(s);
+    case "High":
+      return (s) => import_ansis.default.hex("#ff8c00")(s);
+    case "Warning":
+      return (s) => import_ansis.default.hex("#ffd700")(s);
+    case "Info":
+      return (s) => import_ansis.default.cyan(s);
+    default:
+      return (s) => s;
+  }
+}
+var MAX_PATTERNS_PER_GROUP = 10;
+function formatPatternSummary(summary) {
+  if (!summary || summary.groups.length === 0) return "";
+  const lines = [];
+  lines.push(import_ansis.default.bold("Pattern Summary"));
+  lines.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  if (summary.noisyPatternCount > 0) {
+    const n = summary.noisyPatternCount;
+    lines.push(
+      import_ansis.default.hex("#ff6347")(
+        `${n} noisy pattern${n !== 1 ? "s" : ""} detected (${summary.noisyThreshold}+ issues) \u2014 consider disabling or reconfiguring`
+      )
+    );
+  }
+  lines.push("");
+  let maxLabelLen = 0;
+  let maxCountLen = 0;
+  for (const group of summary.groups) {
+    const visible = group.patterns.slice(0, MAX_PATTERNS_PER_GROUP);
+    for (const p of visible) {
+      const label = `${p.title} (${p.toolDisplayName})`;
+      maxLabelLen = Math.max(maxLabelLen, label.length);
+      const countStr = `${p.issueCount} issue${p.issueCount !== 1 ? "s" : ""}`;
+      maxCountLen = Math.max(maxCountLen, countStr.length);
+    }
+  }
+  for (const group of summary.groups) {
+    const color = severityColorFn(group.severity);
+    lines.push(color(`${group.severityLabel} \u2014 ${group.categoryLabel}`));
+    const visible = group.patterns.slice(0, MAX_PATTERNS_PER_GROUP);
+    const remaining = group.patterns.length - visible.length;
+    for (const pattern of visible) {
+      const label = `${pattern.title} (${pattern.toolDisplayName})`;
+      const countStr = `${pattern.issueCount} issue${pattern.issueCount !== 1 ? "s" : ""}`;
+      const fileStr = `in ${pattern.fileCount} file${pattern.fileCount !== 1 ? "s" : ""}`;
+      const noisyStr = pattern.noisy ? import_ansis.default.bold.red("  NOISY") : "";
+      lines.push(
+        `  ${label.padEnd(maxLabelLen)}  ${countStr.padStart(maxCountLen)}  ${fileStr}${noisyStr}`
+      );
+    }
+    if (remaining > 0) {
+      lines.push(import_ansis.default.dim(`  ... and ${remaining} other pattern${remaining !== 1 ? "s" : ""}`));
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
 
 // src/init.ts
-var import_promises3 = __toESM(require("fs/promises"));
-var import_path6 = __toESM(require("path"));
+var import_promises4 = __toESM(require("fs/promises"));
+var import_path7 = __toESM(require("path"));
 var import_child_process3 = require("child_process");
 var import_tooling5 = require("@codacy/tooling");
 
-// src/codacy-yaml.ts
+// src/discover.ts
 var import_promises2 = __toESM(require("fs/promises"));
 var import_path5 = __toESM(require("path"));
+
+// src/discover-catalog.ts
+var DEPENDENCY_CATALOG = /* @__PURE__ */ new Map([
+  // --- JavaScript / TypeScript — Frameworks ---
+  ["react", { displayName: "React", kind: "framework" }],
+  ["react-dom", { displayName: "React DOM", kind: "framework" }],
+  ["react-native", { displayName: "React Native", kind: "framework" }],
+  ["vue", { displayName: "Vue.js", kind: "framework" }],
+  ["nuxt", { displayName: "Nuxt", kind: "framework" }],
+  ["@angular/core", { displayName: "Angular", kind: "framework" }],
+  ["svelte", { displayName: "Svelte", kind: "framework" }],
+  ["@sveltejs/kit", { displayName: "SvelteKit", kind: "framework" }],
+  ["next", { displayName: "Next.js", kind: "framework" }],
+  ["ember-source", { displayName: "Ember.js", kind: "framework" }],
+  ["lit", { displayName: "Lit", kind: "framework" }],
+  ["solid-js", { displayName: "Solid", kind: "framework" }],
+  ["astro", { displayName: "Astro", kind: "framework" }],
+  ["@builder.io/qwik", { displayName: "Qwik", kind: "framework" }],
+  ["@builder.io/qwik-city", { displayName: "Qwik", kind: "framework" }],
+  ["@remix-run/react", { displayName: "Remix", kind: "framework" }],
+  ["gatsby", { displayName: "Gatsby", kind: "framework" }],
+  ["preact", { displayName: "Preact", kind: "framework" }],
+  ["express", { displayName: "Express", kind: "framework" }],
+  ["@nestjs/core", { displayName: "NestJS", kind: "framework" }],
+  ["fastify", { displayName: "Fastify", kind: "framework" }],
+  ["koa", { displayName: "Koa", kind: "framework" }],
+  ["@hapi/hapi", { displayName: "Hapi", kind: "framework" }],
+  ["hono", { displayName: "Hono", kind: "framework" }],
+  ["electron", { displayName: "Electron", kind: "framework" }],
+  // --- JavaScript / TypeScript — Libraries ---
+  ["lodash", { displayName: "Lodash", kind: "library" }],
+  ["underscore", { displayName: "Underscore.js", kind: "library" }],
+  ["ramda", { displayName: "Ramda", kind: "library" }],
+  ["jest", { displayName: "Jest", kind: "library" }],
+  ["vitest", { displayName: "Vitest", kind: "library" }],
+  ["@playwright/test", { displayName: "Playwright", kind: "library" }],
+  ["playwright", { displayName: "Playwright", kind: "library" }],
+  ["cypress", { displayName: "Cypress", kind: "library" }],
+  ["mocha", { displayName: "Mocha", kind: "library" }],
+  ["ava", { displayName: "AVA", kind: "library" }],
+  ["jasmine", { displayName: "Jasmine", kind: "library" }],
+  ["jasmine-core", { displayName: "Jasmine", kind: "library" }],
+  ["@testing-library/react", { displayName: "Testing Library", kind: "library" }],
+  ["@testing-library/vue", { displayName: "Testing Library", kind: "library" }],
+  ["@testing-library/dom", { displayName: "Testing Library", kind: "library" }],
+  ["tailwindcss", { displayName: "Tailwind CSS", kind: "library" }],
+  ["@storybook/react", { displayName: "Storybook", kind: "library" }],
+  ["@storybook/vue3", { displayName: "Storybook", kind: "library" }],
+  ["@storybook/svelte", { displayName: "Storybook", kind: "library" }],
+  ["redux", { displayName: "Redux", kind: "library" }],
+  ["@reduxjs/toolkit", { displayName: "Redux Toolkit", kind: "library" }],
+  ["mobx", { displayName: "MobX", kind: "library" }],
+  ["zustand", { displayName: "Zustand", kind: "library" }],
+  ["axios", { displayName: "Axios", kind: "library" }],
+  ["date-fns", { displayName: "date-fns", kind: "library" }],
+  ["dayjs", { displayName: "Day.js", kind: "library" }],
+  ["moment", { displayName: "Moment.js", kind: "library" }],
+  ["rxjs", { displayName: "RxJS", kind: "library" }],
+  ["zod", { displayName: "Zod", kind: "library" }],
+  ["joi", { displayName: "Joi", kind: "library" }],
+  ["yup", { displayName: "Yup", kind: "library" }],
+  ["prisma", { displayName: "Prisma", kind: "library" }],
+  ["@prisma/client", { displayName: "Prisma", kind: "library" }],
+  ["typeorm", { displayName: "TypeORM", kind: "library" }],
+  ["sequelize", { displayName: "Sequelize", kind: "library" }],
+  ["drizzle-orm", { displayName: "Drizzle ORM", kind: "library" }],
+  ["mongoose", { displayName: "Mongoose", kind: "library" }],
+  ["graphql", { displayName: "GraphQL", kind: "library" }],
+  ["@apollo/client", { displayName: "Apollo Client", kind: "library" }],
+  ["socket.io", { displayName: "Socket.IO", kind: "library" }],
+  ["three", { displayName: "Three.js", kind: "library" }],
+  ["d3", { displayName: "D3.js", kind: "library" }],
+  ["chart.js", { displayName: "Chart.js", kind: "library" }],
+  ["sass", { displayName: "Sass", kind: "library" }],
+  ["node-sass", { displayName: "Sass", kind: "library" }],
+  ["less", { displayName: "Less", kind: "library" }],
+  ["styled-components", { displayName: "styled-components", kind: "library" }],
+  ["@emotion/react", { displayName: "Emotion", kind: "library" }],
+  ["pino", { displayName: "Pino", kind: "library" }],
+  ["winston", { displayName: "Winston", kind: "library" }],
+  ["i18next", { displayName: "i18next", kind: "library" }],
+  ["react-intl", { displayName: "react-intl", kind: "library" }],
+  ["vue-i18n", { displayName: "vue-i18n", kind: "library" }],
+  ["next-intl", { displayName: "next-intl", kind: "library" }],
+  // --- JavaScript / TypeScript — Tools ---
+  ["typescript", { displayName: "TypeScript", kind: "tool" }],
+  ["eslint", { displayName: "ESLint", kind: "tool" }],
+  ["prettier", { displayName: "Prettier", kind: "tool" }],
+  ["webpack", { displayName: "Webpack", kind: "tool" }],
+  ["vite", { displayName: "Vite", kind: "tool" }],
+  ["esbuild", { displayName: "esbuild", kind: "tool" }],
+  ["rollup", { displayName: "Rollup", kind: "tool" }],
+  ["turbo", { displayName: "Turborepo", kind: "tool" }],
+  ["tsup", { displayName: "tsup", kind: "tool" }],
+  ["@biomejs/biome", { displayName: "Biome", kind: "tool" }],
+  ["stylelint", { displayName: "Stylelint", kind: "tool" }],
+  // --- JavaScript / TypeScript — Platforms ---
+  ["@lwc/engine-dom", { displayName: "Lightning Web Components", kind: "platform" }],
+  ["@salesforce/core", { displayName: "Salesforce", kind: "platform" }],
+  ["@shopify/polaris", { displayName: "Shopify Polaris", kind: "platform" }],
+  // --- Python — Frameworks ---
+  ["django", { displayName: "Django", kind: "framework" }],
+  ["flask", { displayName: "Flask", kind: "framework" }],
+  ["fastapi", { displayName: "FastAPI", kind: "framework" }],
+  ["tornado", { displayName: "Tornado", kind: "framework" }],
+  ["pyramid", { displayName: "Pyramid", kind: "framework" }],
+  ["starlette", { displayName: "Starlette", kind: "framework" }],
+  ["sanic", { displayName: "Sanic", kind: "framework" }],
+  ["bottle", { displayName: "Bottle", kind: "framework" }],
+  ["streamlit", { displayName: "Streamlit", kind: "framework" }],
+  ["gradio", { displayName: "Gradio", kind: "framework" }],
+  ["apache-airflow", { displayName: "Airflow", kind: "framework" }],
+  // --- Python — Libraries ---
+  ["flask-babel", { displayName: "Flask-Babel", kind: "library" }],
+  ["pytest", { displayName: "pytest", kind: "library" }],
+  ["numpy", { displayName: "NumPy", kind: "library" }],
+  ["pandas", { displayName: "pandas", kind: "library" }],
+  ["requests", { displayName: "Requests", kind: "library" }],
+  ["sqlalchemy", { displayName: "SQLAlchemy", kind: "library" }],
+  ["celery", { displayName: "Celery", kind: "library" }],
+  ["pydantic", { displayName: "Pydantic", kind: "library" }],
+  ["boto3", { displayName: "Boto3 (AWS SDK)", kind: "library" }],
+  ["scipy", { displayName: "SciPy", kind: "library" }],
+  ["scikit-learn", { displayName: "scikit-learn", kind: "library" }],
+  ["tensorflow", { displayName: "TensorFlow", kind: "library" }],
+  ["torch", { displayName: "PyTorch", kind: "library" }],
+  ["httpx", { displayName: "HTTPX", kind: "library" }],
+  ["aiohttp", { displayName: "aiohttp", kind: "library" }],
+  ["pillow", { displayName: "Pillow", kind: "library" }],
+  ["beautifulsoup4", { displayName: "Beautiful Soup", kind: "library" }],
+  ["scrapy", { displayName: "Scrapy", kind: "library" }],
+  ["alembic", { displayName: "Alembic", kind: "library" }],
+  ["marshmallow", { displayName: "Marshmallow", kind: "library" }],
+  ["click", { displayName: "Click", kind: "library" }],
+  ["typer", { displayName: "Typer", kind: "library" }],
+  ["rich", { displayName: "Rich", kind: "library" }],
+  ["polars", { displayName: "Polars", kind: "library" }],
+  ["dask", { displayName: "Dask", kind: "library" }],
+  ["matplotlib", { displayName: "Matplotlib", kind: "library" }],
+  ["seaborn", { displayName: "Seaborn", kind: "library" }],
+  ["plotly", { displayName: "Plotly", kind: "library" }],
+  // --- Python — Tools ---
+  ["black", { displayName: "Black", kind: "tool" }],
+  ["ruff", { displayName: "Ruff", kind: "tool" }],
+  ["mypy", { displayName: "mypy", kind: "tool" }],
+  ["pylint", { displayName: "Pylint", kind: "tool" }],
+  ["flake8", { displayName: "Flake8", kind: "tool" }],
+  ["bandit", { displayName: "Bandit", kind: "tool" }],
+  ["isort", { displayName: "isort", kind: "tool" }],
+  // --- Ruby — Frameworks ---
+  ["rails", { displayName: "Ruby on Rails", kind: "framework" }],
+  ["sinatra", { displayName: "Sinatra", kind: "framework" }],
+  ["hanami", { displayName: "Hanami", kind: "framework" }],
+  ["grape", { displayName: "Grape", kind: "framework" }],
+  ["padrino", { displayName: "Padrino", kind: "framework" }],
+  // --- Ruby — Libraries ---
+  ["rspec", { displayName: "RSpec", kind: "library" }],
+  ["rspec-core", { displayName: "RSpec", kind: "library" }],
+  ["rspec-rails", { displayName: "RSpec Rails", kind: "library" }],
+  ["capybara", { displayName: "Capybara", kind: "library" }],
+  ["sidekiq", { displayName: "Sidekiq", kind: "library" }],
+  ["devise", { displayName: "Devise", kind: "library" }],
+  ["pundit", { displayName: "Pundit", kind: "library" }],
+  ["activeadmin", { displayName: "ActiveAdmin", kind: "library" }],
+  ["puma", { displayName: "Puma", kind: "library" }],
+  ["nokogiri", { displayName: "Nokogiri", kind: "library" }],
+  ["faraday", { displayName: "Faraday", kind: "library" }],
+  ["httparty", { displayName: "HTTParty", kind: "library" }],
+  ["minitest", { displayName: "Minitest", kind: "library" }],
+  ["factory_bot", { displayName: "FactoryBot", kind: "library" }],
+  ["dry-validation", { displayName: "dry-validation", kind: "library" }],
+  // --- Ruby — Tools ---
+  ["rubocop", { displayName: "RuboCop", kind: "tool" }],
+  ["bundler", { displayName: "Bundler", kind: "tool" }],
+  ["solargraph", { displayName: "Solargraph", kind: "tool" }],
+  // --- Java / Kotlin — Frameworks ---
+  ["spring-boot-starter", { displayName: "Spring Boot", kind: "framework" }],
+  ["spring-boot-starter-web", { displayName: "Spring Boot", kind: "framework" }],
+  ["spring-core", { displayName: "Spring Framework", kind: "framework" }],
+  ["quarkus-core", { displayName: "Quarkus", kind: "framework" }],
+  ["micronaut-core", { displayName: "Micronaut", kind: "framework" }],
+  ["ktor-server-core", { displayName: "Ktor", kind: "framework" }],
+  ["android", { displayName: "Android SDK", kind: "framework" }],
+  // --- Java / Kotlin — Libraries ---
+  ["junit-jupiter", { displayName: "JUnit 5", kind: "library" }],
+  ["junit", { displayName: "JUnit", kind: "library" }],
+  ["junit-jupiter-api", { displayName: "JUnit 5", kind: "library" }],
+  ["mockito-core", { displayName: "Mockito", kind: "library" }],
+  ["lombok", { displayName: "Lombok", kind: "library" }],
+  ["jackson-databind", { displayName: "Jackson", kind: "library" }],
+  ["jackson-core", { displayName: "Jackson", kind: "library" }],
+  ["hibernate-core", { displayName: "Hibernate", kind: "library" }],
+  ["guava", { displayName: "Guava", kind: "library" }],
+  ["commons-lang3", { displayName: "Apache Commons Lang", kind: "library" }],
+  ["commons-io", { displayName: "Apache Commons IO", kind: "library" }],
+  ["slf4j-api", { displayName: "SLF4J", kind: "library" }],
+  ["log4j-core", { displayName: "Log4j", kind: "library" }],
+  ["logback-classic", { displayName: "Logback", kind: "library" }],
+  ["testng", { displayName: "TestNG", kind: "library" }],
+  ["assertj-core", { displayName: "AssertJ", kind: "library" }],
+  ["gson", { displayName: "Gson", kind: "library" }],
+  ["okhttp", { displayName: "OkHttp", kind: "library" }],
+  ["retrofit", { displayName: "Retrofit", kind: "library" }],
+  // --- Go — Frameworks ---
+  ["github.com/gin-gonic/gin", { displayName: "Gin", kind: "framework" }],
+  ["github.com/labstack/echo", { displayName: "Echo", kind: "framework" }],
+  ["github.com/gofiber/fiber", { displayName: "Fiber", kind: "framework" }],
+  ["github.com/go-chi/chi", { displayName: "Chi", kind: "framework" }],
+  ["github.com/gorilla/mux", { displayName: "Gorilla Mux", kind: "framework" }],
+  ["github.com/beego/beego", { displayName: "Beego", kind: "framework" }],
+  // --- Go — Libraries ---
+  ["github.com/stretchr/testify", { displayName: "Testify", kind: "library" }],
+  ["github.com/spf13/cobra", { displayName: "Cobra", kind: "library" }],
+  ["github.com/spf13/viper", { displayName: "Viper", kind: "library" }],
+  ["go.uber.org/zap", { displayName: "Zap", kind: "library" }],
+  ["github.com/sirupsen/logrus", { displayName: "Logrus", kind: "library" }],
+  ["gorm.io/gorm", { displayName: "GORM", kind: "library" }],
+  ["github.com/go-kit/kit", { displayName: "Go Kit", kind: "library" }],
+  ["google.golang.org/protobuf", { displayName: "Protocol Buffers", kind: "library" }],
+  ["google.golang.org/grpc", { displayName: "gRPC", kind: "library" }],
+  ["github.com/jackc/pgx", { displayName: "pgx", kind: "library" }],
+  ["github.com/redis/go-redis", { displayName: "go-redis", kind: "library" }],
+  ["github.com/aws/aws-sdk-go-v2", { displayName: "AWS SDK for Go", kind: "library" }],
+  ["github.com/prometheus/client_golang", { displayName: "Prometheus Client", kind: "library" }],
+  // --- Rust — Frameworks ---
+  ["actix-web", { displayName: "Actix Web", kind: "framework" }],
+  ["axum", { displayName: "Axum", kind: "framework" }],
+  ["rocket", { displayName: "Rocket", kind: "framework" }],
+  ["warp", { displayName: "Warp", kind: "framework" }],
+  ["tauri", { displayName: "Tauri", kind: "framework" }],
+  // --- Rust — Libraries ---
+  ["tokio", { displayName: "Tokio", kind: "library" }],
+  ["serde", { displayName: "Serde", kind: "library" }],
+  ["clap", { displayName: "clap", kind: "library" }],
+  ["reqwest", { displayName: "reqwest", kind: "library" }],
+  ["diesel", { displayName: "Diesel", kind: "library" }],
+  ["sqlx", { displayName: "SQLx", kind: "library" }],
+  ["tracing", { displayName: "Tracing", kind: "library" }],
+  ["anyhow", { displayName: "anyhow", kind: "library" }],
+  ["thiserror", { displayName: "thiserror", kind: "library" }],
+  ["rayon", { displayName: "Rayon", kind: "library" }],
+  // --- PHP — Frameworks ---
+  ["laravel/framework", { displayName: "Laravel", kind: "framework" }],
+  ["symfony/framework-bundle", { displayName: "Symfony", kind: "framework" }],
+  ["codeigniter4/framework", { displayName: "CodeIgniter", kind: "framework" }],
+  ["slim/slim", { displayName: "Slim", kind: "framework" }],
+  ["cakephp/cakephp", { displayName: "CakePHP", kind: "framework" }],
+  // --- PHP — Libraries ---
+  ["phpunit/phpunit", { displayName: "PHPUnit", kind: "library" }],
+  ["guzzlehttp/guzzle", { displayName: "Guzzle", kind: "library" }],
+  ["monolog/monolog", { displayName: "Monolog", kind: "library" }],
+  ["nesbot/carbon", { displayName: "Carbon", kind: "library" }],
+  ["doctrine/orm", { displayName: "Doctrine ORM", kind: "library" }],
+  ["doctrine/dbal", { displayName: "Doctrine DBAL", kind: "library" }],
+  ["league/flysystem", { displayName: "Flysystem", kind: "library" }],
+  ["php-amqplib/php-amqplib", { displayName: "php-amqplib", kind: "library" }],
+  ["predis/predis", { displayName: "Predis", kind: "library" }],
+  // --- PHP — Tools ---
+  ["phpstan/phpstan", { displayName: "PHPStan", kind: "tool" }],
+  ["squizlabs/php_codesniffer", { displayName: "PHP_CodeSniffer", kind: "tool" }],
+  // --- Swift — Frameworks ---
+  ["vapor", { displayName: "Vapor", kind: "framework" }],
+  // --- Swift — Libraries ---
+  ["Alamofire", { displayName: "Alamofire", kind: "library" }],
+  ["SnapKit", { displayName: "SnapKit", kind: "library" }],
+  ["Kingfisher", { displayName: "Kingfisher", kind: "library" }],
+  ["Moya", { displayName: "Moya", kind: "library" }],
+  ["RxSwift", { displayName: "RxSwift", kind: "library" }],
+  ["RealmSwift", { displayName: "Realm", kind: "library" }],
+  // --- Scala — Frameworks ---
+  ["play-server", { displayName: "Play Framework", kind: "framework" }],
+  ["akka-actor", { displayName: "Akka", kind: "framework" }],
+  // --- Scala — Libraries ---
+  ["scalatest", { displayName: "ScalaTest", kind: "library" }],
+  ["specs2-core", { displayName: "Specs2", kind: "library" }],
+  ["cats-core", { displayName: "Cats", kind: "library" }],
+  ["circe-core", { displayName: "Circe", kind: "library" }]
+]);
+var DEPENDENCY_PREFIX_RULES = [
+  { prefix: "@angular/", classification: { displayName: "Angular", kind: "framework" } },
+  { prefix: "@nestjs/", classification: { displayName: "NestJS", kind: "framework" } },
+  { prefix: "@remix-run/", classification: { displayName: "Remix", kind: "framework" } },
+  { prefix: "@sveltejs/", classification: { displayName: "SvelteKit", kind: "framework" } },
+  { prefix: "@nuxt/", classification: { displayName: "Nuxt", kind: "framework" } },
+  { prefix: "@storybook/", classification: { displayName: "Storybook", kind: "library" } },
+  {
+    prefix: "@testing-library/",
+    classification: { displayName: "Testing Library", kind: "library" }
+  },
+  { prefix: "@tanstack/", classification: { displayName: "TanStack", kind: "library" } },
+  { prefix: "@reduxjs/", classification: { displayName: "Redux", kind: "library" } },
+  { prefix: "@prisma/", classification: { displayName: "Prisma", kind: "library" } },
+  { prefix: "@apollo/", classification: { displayName: "Apollo", kind: "library" } },
+  { prefix: "@formatjs/", classification: { displayName: "react-intl", kind: "library" } },
+  { prefix: "@lingui/", classification: { displayName: "Lingui", kind: "library" } },
+  { prefix: "@emotion/", classification: { displayName: "Emotion", kind: "library" } },
+  { prefix: "@mui/", classification: { displayName: "Material UI", kind: "library" } },
+  { prefix: "@chakra-ui/", classification: { displayName: "Chakra UI", kind: "library" } },
+  {
+    prefix: "@lwc/",
+    classification: { displayName: "Lightning Web Components", kind: "platform" }
+  },
+  { prefix: "@salesforce/", classification: { displayName: "Salesforce", kind: "platform" } },
+  { prefix: "@shopify/", classification: { displayName: "Shopify", kind: "platform" } },
+  { prefix: "@aws-sdk/", classification: { displayName: "AWS SDK", kind: "library" } },
+  { prefix: "@google-cloud/", classification: { displayName: "Google Cloud", kind: "library" } },
+  { prefix: "@azure/", classification: { displayName: "Azure SDK", kind: "library" } }
+];
+function classifyDependency(name) {
+  const exact = DEPENDENCY_CATALOG.get(name);
+  if (exact) return exact;
+  for (const rule of DEPENDENCY_PREFIX_RULES) {
+    if (name.startsWith(rule.prefix)) return rule.classification;
+  }
+  return void 0;
+}
+var NOTABLE_ANY_DEPTH = /* @__PURE__ */ new Set([
+  "Dockerfile",
+  "docker-compose.yml",
+  "docker-compose.yaml",
+  "compose.yml",
+  "compose.yaml",
+  "Makefile",
+  "Justfile",
+  "pom.xml",
+  "build.gradle",
+  "build.gradle.kts",
+  "build.sbt",
+  "go.mod",
+  "Cargo.toml",
+  "Gemfile",
+  "Podfile",
+  "Package.swift",
+  "Jenkinsfile",
+  "Vagrantfile",
+  "Procfile"
+]);
+var NOTABLE_ROOT_ONLY = /* @__PURE__ */ new Set([
+  ".dockerignore",
+  "Taskfile.yml",
+  "Rakefile",
+  "Gruntfile.js",
+  "Gulpfile.js",
+  "settings.gradle",
+  "settings.gradle.kts",
+  "go.sum",
+  "Cargo.lock",
+  "CLAUDE.md",
+  "AGENTS.md",
+  "agents.md",
+  ".cursorrules",
+  "copilot-instructions.md",
+  ".travis.yml",
+  ".gitlab-ci.yml",
+  "azure-pipelines.yml",
+  "bitbucket-pipelines.yml",
+  "appveyor.yml",
+  "package.json",
+  "requirements.txt",
+  "pyproject.toml",
+  "Pipfile",
+  "composer.json",
+  "tsconfig.json",
+  "jsconfig.json",
+  "serverless.yml",
+  "serverless.yaml",
+  "cdk.json",
+  "pulumi.yaml",
+  "README.md",
+  "CHANGELOG.md",
+  "CONTRIBUTING.md",
+  "LICENSE",
+  "renovate.json",
+  ".nvmrc",
+  ".node-version",
+  ".python-version",
+  ".ruby-version",
+  ".tool-versions"
+]);
+var NOTABLE_PATH_PREFIXES = [".github/workflows/", ".circleci/", ".gitlab/"];
+var CONFIG_HEURISTIC_PATTERNS = [
+  /^\..*rc$/,
+  // .eslintrc, .prettierrc, etc.
+  /^\..*rc\.(json|js|cjs|mjs|yml|yaml|ts)$/,
+  // .eslintrc.json, etc.
+  /^.*\.config\.(js|ts|mjs|cjs)$/,
+  // vite.config.ts, jest.config.js, etc.
+  /^\.env(\..+)?$/
+  // .env, .env.local, .env.production
+];
+function isNotableFile(filePath) {
+  const basename = filePath.split("/").pop() ?? filePath;
+  const isRoot = !filePath.includes("/");
+  if (NOTABLE_ANY_DEPTH.has(basename)) return true;
+  if (isRoot && NOTABLE_ROOT_ONLY.has(basename)) return true;
+  for (const prefix of NOTABLE_PATH_PREFIXES) {
+    if (filePath.startsWith(prefix)) return true;
+  }
+  if (!filePath.includes("/")) {
+    for (const pattern of CONFIG_HEURISTIC_PATTERNS) {
+      if (pattern.test(basename)) return true;
+    }
+  }
+  return false;
+}
+function parsePackageJson(content) {
+  try {
+    const pkg = JSON.parse(content);
+    const deps = [];
+    for (const section of ["dependencies", "devDependencies", "peerDependencies"]) {
+      const entries2 = pkg[section];
+      if (entries2 && typeof entries2 === "object") {
+        for (const [name, version] of Object.entries(entries2)) {
+          deps.push({ name, version: typeof version === "string" ? version : void 0 });
+        }
+      }
+    }
+    return deps;
+  } catch {
+    return [];
+  }
+}
+function parseRequirementsTxt(content) {
+  const deps = [];
+  for (const rawLine of content.split("\n")) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#") || line.startsWith("-")) continue;
+    const noComment = line.split("#")[0].trim();
+    if (!noComment) continue;
+    const match = noComment.match(/^([a-zA-Z0-9_.-]+(?:\[[^\]]*\])?)\s*([<>=!~@;].*)?$/);
+    if (match) {
+      const rawName = match[1].replace(/\[.*\]$/, "");
+      const normalized = rawName.toLowerCase().replace(/_/g, "-");
+      deps.push({ name: normalized, version: match[2]?.trim() });
+    }
+  }
+  return deps;
+}
+function parsePyprojectToml(content) {
+  const deps = [];
+  const projectDepsMatch = content.match(/\[project\][\s\S]*?dependencies\s*=\s*\[([\s\S]*?)\]/);
+  if (projectDepsMatch) {
+    const items = projectDepsMatch[1].match(/"([^"]+)"|'([^']+)'/g) ?? [];
+    for (const item of items) {
+      const raw = item.replace(/["']/g, "");
+      const name = raw.split(/[<>=!~;\s]/)[0].replace(/\[.*\]$/, "");
+      if (name) deps.push({ name: name.toLowerCase().replace(/_/g, "-") });
+    }
+  }
+  const poetryMatch = content.match(/\[tool\.poetry\.dependencies\]([\s\S]*?)(?:\n\[|\n$)/);
+  if (poetryMatch) {
+    const lines = poetryMatch[1].split("\n");
+    for (const line of lines) {
+      const m = line.match(/^([a-zA-Z0-9_.-]+)\s*=/);
+      if (m && m[1] !== "python") {
+        deps.push({ name: m[1].toLowerCase().replace(/_/g, "-") });
+      }
+    }
+  }
+  const poetryGroupRegex = /\[tool\.poetry\.group\.\w+\.dependencies\]([\s\S]*?)(?:\n\[|\n$)/g;
+  let groupMatch;
+  while ((groupMatch = poetryGroupRegex.exec(content)) !== null) {
+    const lines = groupMatch[1].split("\n");
+    for (const line of lines) {
+      const m = line.match(/^([a-zA-Z0-9_.-]+)\s*=/);
+      if (m) {
+        deps.push({ name: m[1].toLowerCase().replace(/_/g, "-") });
+      }
+    }
+  }
+  return deps;
+}
+function parsePipfile(content) {
+  const deps = [];
+  let inDepsSection = false;
+  for (const rawLine of content.split("\n")) {
+    const line = rawLine.trim();
+    if (/^\[(packages|dev-packages)\]/.test(line)) {
+      inDepsSection = true;
+      continue;
+    }
+    if (line.startsWith("[")) {
+      inDepsSection = false;
+      continue;
+    }
+    if (inDepsSection) {
+      const m = line.match(/^([a-zA-Z0-9_.-]+)\s*=/);
+      if (m) {
+        deps.push({ name: m[1].toLowerCase().replace(/_/g, "-") });
+      }
+    }
+  }
+  return deps;
+}
+function parseGemfile(content) {
+  const deps = [];
+  const gemRegex = /^\s*gem\s+["']([^"']+)["'](?:\s*,\s*["']([^"']+)["'])?/gm;
+  let match;
+  while ((match = gemRegex.exec(content)) !== null) {
+    deps.push({ name: match[1], version: match[2] });
+  }
+  return deps;
+}
+function parseGoMod(content) {
+  const deps = [];
+  const singleRegex = /^require\s+(\S+)\s+(\S+)/gm;
+  let match;
+  while ((match = singleRegex.exec(content)) !== null) {
+    if (!match[1].startsWith("(")) {
+      deps.push({ name: match[1], version: match[2] });
+    }
+  }
+  const blockRegex = /require\s*\(([\s\S]*?)\)/g;
+  while ((match = blockRegex.exec(content)) !== null) {
+    const lines = match[1].split("\n");
+    for (const line of lines) {
+      const m = line.trim().match(/^(\S+)\s+(\S+)/);
+      if (m && !m[1].startsWith("//")) {
+        deps.push({ name: m[1], version: m[2] });
+      }
+    }
+  }
+  return deps;
+}
+function parsePomXml(content) {
+  const deps = [];
+  const depRegex = /<dependency>[\s\S]*?<artifactId>([^<]+)<\/artifactId>[\s\S]*?<\/dependency>/g;
+  let match;
+  while ((match = depRegex.exec(content)) !== null) {
+    deps.push({ name: match[1].trim() });
+  }
+  return deps;
+}
+function parseBuildGradle(content) {
+  const deps = [];
+  const depRegex = /(?:implementation|testImplementation|api|compileOnly|runtimeOnly|kapt|annotationProcessor)\s*(?:\(\s*)?["']([^"':]+):([^"':]+)(?::([^"']+))?["']/g;
+  let match;
+  while ((match = depRegex.exec(content)) !== null) {
+    deps.push({ name: match[2].trim(), version: match[3]?.trim() });
+  }
+  return deps;
+}
+function parseCargoToml(content) {
+  const deps = [];
+  let inDepsSection = false;
+  for (const rawLine of content.split("\n")) {
+    const line = rawLine.trim();
+    if (/^\[((?:dev-|build-)?dependencies)\]/.test(line)) {
+      inDepsSection = true;
+      continue;
+    }
+    if (line.startsWith("[") && !line.includes("dependencies.")) {
+      inDepsSection = false;
+      continue;
+    }
+    if (inDepsSection) {
+      const m = line.match(/^([a-zA-Z0-9_-]+)\s*=/);
+      if (m) {
+        const versionMatch = line.match(/["']([^"']+)["']/);
+        deps.push({ name: m[1], version: versionMatch?.[1] });
+      }
+    }
+  }
+  return deps;
+}
+function parseComposerJson(content) {
+  try {
+    const pkg = JSON.parse(content);
+    const deps = [];
+    for (const section of ["require", "require-dev"]) {
+      const entries2 = pkg[section];
+      if (entries2 && typeof entries2 === "object") {
+        for (const [name, version] of Object.entries(entries2)) {
+          if (name === "php" || name.startsWith("ext-")) continue;
+          deps.push({ name, version: typeof version === "string" ? version : void 0 });
+        }
+      }
+    }
+    return deps;
+  } catch {
+    return [];
+  }
+}
+function parsePodfile(content) {
+  const deps = [];
+  const podRegex = /^\s*pod\s+["']([^"']+)["'](?:\s*,\s*["']([^"']+)["'])?/gm;
+  let match;
+  while ((match = podRegex.exec(content)) !== null) {
+    deps.push({ name: match[1], version: match[2] });
+  }
+  return deps;
+}
+function parsePackageSwift(content) {
+  const deps = [];
+  const pkgRegex = /\.package\s*\(\s*url:\s*["'](?:https?:\/\/[^/]+\/[^/]+\/|git@[^:]+:[^/]+\/)([^"'/.]+)/g;
+  let match;
+  while ((match = pkgRegex.exec(content)) !== null) {
+    deps.push({ name: match[1] });
+  }
+  return deps;
+}
+var MANIFEST_PARSERS = /* @__PURE__ */ new Map([
+  ["package.json", parsePackageJson],
+  ["requirements.txt", parseRequirementsTxt],
+  ["pyproject.toml", parsePyprojectToml],
+  ["Pipfile", parsePipfile],
+  ["Gemfile", parseGemfile],
+  ["go.mod", parseGoMod],
+  ["pom.xml", parsePomXml],
+  ["build.gradle", parseBuildGradle],
+  ["build.gradle.kts", parseBuildGradle],
+  ["Cargo.toml", parseCargoToml],
+  ["composer.json", parseComposerJson],
+  ["Podfile", parsePodfile],
+  ["Package.swift", parsePackageSwift]
+]);
+
+// src/discover.ts
+async function discover(repositoryRoot, options) {
+  const files = listRepoFiles(repositoryRoot);
+  const filePatterns = extractFilePatterns(files);
+  const notableFiles = findNotableFiles(files);
+  const languages = await detectLanguages(repositoryRoot, files);
+  let frameworks = [];
+  let libraries = [];
+  if (!options?.skipDependencies) {
+    const allDeps = await extractDependencies(repositoryRoot, files);
+    frameworks = deduplicateDeps(allDeps.filter((d) => d.kind === "framework"));
+    libraries = deduplicateDeps(
+      allDeps.filter((d) => d.kind === "library" || d.kind === "platform" || d.kind === "tool")
+    );
+  }
+  return {
+    filePatterns,
+    notableFiles,
+    languages,
+    frameworks,
+    libraries,
+    metadata: {
+      repositoryRoot: import_path5.default.resolve(repositoryRoot),
+      totalFiles: files.length,
+      scannedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function extractFilePatterns(files) {
+  const extensions = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const ext = import_path5.default.extname(file).toLowerCase();
+    if (ext) {
+      extensions.add(`*${ext}`);
+    }
+  }
+  return Array.from(extensions).sort();
+}
+function findNotableFiles(files) {
+  const notable = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    if (isNotableFile(file)) {
+      notable.add(file);
+    }
+  }
+  return Array.from(notable).sort();
+}
+async function extractDependencies(repositoryRoot, files) {
+  const manifestFiles = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const basename = file.split("/").pop() ?? file;
+    if (MANIFEST_PARSERS.has(basename)) {
+      const existing = manifestFiles.get(basename) ?? [];
+      existing.push(file);
+      manifestFiles.set(basename, existing);
+    }
+  }
+  const allDeps = [];
+  for (const [manifestName, paths] of manifestFiles) {
+    const parser = MANIFEST_PARSERS.get(manifestName);
+    for (const filePath of paths) {
+      let content;
+      try {
+        content = await import_promises2.default.readFile(import_path5.default.join(repositoryRoot, filePath), "utf-8");
+      } catch {
+        continue;
+      }
+      const rawDeps = parser(content);
+      for (const raw of rawDeps) {
+        const classification = classifyDependency(raw.name);
+        if (classification) {
+          allDeps.push({
+            name: raw.name,
+            displayName: classification.displayName,
+            kind: classification.kind,
+            source: "manifest",
+            manifestFile: filePath,
+            version: raw.version
+          });
+        }
+      }
+    }
+  }
+  return allDeps;
+}
+function deduplicateDeps(deps) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const dep of deps) {
+    if (!seen.has(dep.displayName)) {
+      seen.add(dep.displayName);
+      result.push(dep);
+    }
+  }
+  return result.sort((a, b) => a.displayName.localeCompare(b.displayName));
+}
+
+// src/codacy-yaml.ts
+var import_promises3 = __toESM(require("fs/promises"));
+var import_path6 = __toESM(require("path"));
 var import_yaml = require("yaml");
 async function readCodacyYaml(repositoryRoot) {
   const candidates = [".codacy.yaml", ".codacy.yml"];
   let raw = null;
   for (const filename of candidates) {
     try {
-      raw = await import_promises2.default.readFile(import_path5.default.join(repositoryRoot, filename), "utf-8");
+      raw = await import_promises3.default.readFile(import_path6.default.join(repositoryRoot, filename), "utf-8");
       break;
     } catch {
     }
@@ -1515,13 +2427,13 @@ var getQueryString = (params) => {
 };
 var getUrl = (config, options) => {
   const encoder = config.ENCODE_PATH || encodeURI;
-  const path8 = options.url.replace("{api-version}", config.VERSION).replace(/{(.*?)}/g, (substring, group) => {
+  const path9 = options.url.replace("{api-version}", config.VERSION).replace(/{(.*?)}/g, (substring, group) => {
     if (options.path?.hasOwnProperty(group)) {
       return encoder(String(options.path[group]));
     }
     return substring;
   });
-  const url = `${config.BASE}${path8}`;
+  const url = `${config.BASE}${path9}`;
   if (options.query) {
     return `${url}${getQueryString(options.query)}`;
   }
@@ -4865,22 +5777,26 @@ async function listIgnoredFiles(provider, org, repo) {
 }
 
 // src/init.ts
-async function detectLanguages(repositoryRoot) {
-  let files = [];
-  try {
-    const output = (0, import_child_process3.execSync)("git ls-files", {
-      cwd: repositoryRoot,
-      encoding: "utf-8",
-      maxBuffer: 50 * 1024 * 1024
-    }).trim();
-    files = output ? output.split("\n") : [];
-  } catch {
-    return [];
+async function detectLanguages(repositoryRoot, precomputedFiles) {
+  let files;
+  if (precomputedFiles) {
+    files = precomputedFiles;
+  } else {
+    try {
+      const output = (0, import_child_process3.execSync)("git ls-files", {
+        cwd: repositoryRoot,
+        encoding: "utf-8",
+        maxBuffer: 50 * 1024 * 1024
+      }).trim();
+      files = output ? output.split("\n") : [];
+    } catch {
+      return [];
+    }
   }
   const detected = /* @__PURE__ */ new Set();
   for (const file of files) {
-    const basename = import_path6.default.basename(file);
-    const ext = import_path6.default.extname(file).toLowerCase();
+    const basename = import_path7.default.basename(file);
+    const ext = import_path7.default.extname(file).toLowerCase();
     for (const [lang, config] of Object.entries(import_tooling5.LANGUAGE_CONFIG)) {
       if (config.extensions.includes(ext)) {
         detected.add(lang);
@@ -4897,9 +5813,9 @@ async function detectLocalConfigFiles(repositoryRoot, adapters) {
     adapters.map(async (adapter) => {
       const result = await adapter.checkLocalConfigurationFile({
         repositoryRoot,
-        generatedConfigDir: import_path6.default.join(repositoryRoot, ".codacy", "generated"),
-        globalDir: import_path6.default.join(process.env.HOME ?? "~", ".codacy"),
-        toolInstallDir: import_path6.default.join(process.env.HOME ?? "~", ".codacy", "tools", adapter.id),
+        generatedConfigDir: import_path7.default.join(repositoryRoot, ".codacy", "generated"),
+        globalDir: import_path7.default.join(process.env.HOME ?? "~", ".codacy"),
+        toolInstallDir: import_path7.default.join(process.env.HOME ?? "~", ".codacy", "tools", adapter.id),
         targetFiles: [],
         platform: { os: process.platform, arch: process.arch },
         logger: silentLogger,
@@ -5096,10 +6012,10 @@ async function initRemoteConfig(repositoryRoot, provider, organization, reposito
   };
 }
 async function initContainerConfig(repositoryRoot, adapters) {
-  const codacyrcPath = import_path6.default.join(repositoryRoot, ".codacyrc");
+  const codacyrcPath = import_path7.default.join(repositoryRoot, ".codacyrc");
   let raw;
   try {
-    raw = await import_promises3.default.readFile(codacyrcPath, "utf-8");
+    raw = await import_promises4.default.readFile(codacyrcPath, "utf-8");
   } catch {
     throw new Error(`.codacyrc not found at ${codacyrcPath}`);
   }
@@ -5150,10 +6066,257 @@ async function initContainerConfig(repositoryRoot, adapters) {
   }
   return createCodacyConfig({ source: "container", tools, includeFiles });
 }
+async function initAutoConfig(repositoryRoot, adapters, descriptors, filters, onDiscoveryComplete, rawFilterString) {
+  const discoveryResult = await discover(repositoryRoot);
+  onDiscoveryComplete?.(discoveryResult);
+  const detectedKeys = /* @__PURE__ */ new Set();
+  for (const lang of discoveryResult.languages) detectedKeys.add(lang);
+  for (const fw of discoveryResult.frameworks) detectedKeys.add(fw.displayName);
+  for (const lib of discoveryResult.libraries) detectedKeys.add(lib.displayName);
+  const repoLanguages = new Set(discoveryResult.languages);
+  const localConfigs = await detectLocalConfigFiles(repositoryRoot, adapters);
+  const descriptorMap = new Map(descriptors.map((d) => [d.id, d]));
+  const candidates = [];
+  for (const adapter of adapters) {
+    if (!adapter.languages.includes("*") && adapter.languages.length > 0 && repoLanguages.size > 0) {
+      const hasOverlap = adapter.languages.some((lang) => repoLanguages.has(lang));
+      if (!hasOverlap) continue;
+    }
+    candidates.push(adapter);
+  }
+  const deduped = deduplicateToolFamilies(candidates, localConfigs);
+  const tools = [];
+  for (const adapter of deduped) {
+    const localConfigPath = localConfigs.get(adapter.id);
+    if (localConfigPath) {
+      tools.push({
+        toolId: adapter.id,
+        localConfigurationFile: localConfigPath,
+        useLocalConfigurationFile: true,
+        patterns: []
+      });
+      continue;
+    }
+    const patternsMetadata = adapter.patternsMetadata;
+    if (!patternsMetadata || patternsMetadata.length === 0) continue;
+    const desc = descriptorMap.get(adapter.id);
+    const mappings = desc?.frameworkMappings;
+    const selectedPatterns = filterAutoPatterns(
+      patternsMetadata,
+      mappings,
+      detectedKeys,
+      repoLanguages,
+      filters
+    );
+    if (selectedPatterns.length > 0) {
+      tools.push({
+        toolId: adapter.id,
+        patterns: selectedPatterns.map((p) => ({ patternId: p.id }))
+      });
+    }
+  }
+  const baseConfig = createCodacyConfig({
+    source: "auto",
+    languages: discoveryResult.languages,
+    tools,
+    autoFilters: rawFilterString || void 0
+  });
+  const { config, codacyYamlApplied } = await enrichWithCodacyYaml(
+    baseConfig,
+    repositoryRoot,
+    adapters
+  );
+  return {
+    config,
+    stats: {
+      detectedLanguages: discoveryResult.languages.length,
+      detectedFrameworks: discoveryResult.frameworks.length,
+      detectedLibraries: discoveryResult.libraries.length,
+      selectedTools: tools.length,
+      codacyYamlApplied
+    }
+  };
+}
+function toolFamily(id) {
+  return id.replace(/\d+$/, "");
+}
+function deduplicateToolFamilies(candidates, localConfigs) {
+  const families = /* @__PURE__ */ new Map();
+  for (const adapter of candidates) {
+    const family = toolFamily(adapter.id);
+    const group = families.get(family) ?? [];
+    group.push(adapter);
+    families.set(family, group);
+  }
+  const result = [];
+  for (const group of families.values()) {
+    if (group.length === 1) {
+      result.push(group[0]);
+      continue;
+    }
+    const withConfig = group.filter((a) => localConfigs.has(a.id));
+    if (withConfig.length === 1) {
+      result.push(withConfig[0]);
+      continue;
+    }
+    group.sort((a, b) => {
+      const majorA = parseInt(a.preferredVersion.split(".")[0], 10) || 0;
+      const majorB = parseInt(b.preferredVersion.split(".")[0], 10) || 0;
+      return majorB - majorA;
+    });
+    result.push(group[0]);
+  }
+  return result;
+}
+function filterAutoPatterns(patterns, mappings, detectedKeys, repoLanguages, filters) {
+  const allMappedPrefixes = [];
+  const prefixToKeys = /* @__PURE__ */ new Map();
+  const allMappedTags = [];
+  const tagToKeys = /* @__PURE__ */ new Map();
+  if (mappings) {
+    for (const [key, entry] of Object.entries(mappings)) {
+      if (entry.prefixes) {
+        for (const prefix of entry.prefixes) {
+          allMappedPrefixes.push(prefix);
+          const existing = prefixToKeys.get(prefix) ?? [];
+          existing.push(key);
+          prefixToKeys.set(prefix, existing);
+        }
+      }
+      if (entry.tags) {
+        for (const tag of entry.tags) {
+          if (!allMappedTags.includes(tag)) allMappedTags.push(tag);
+          const existing = tagToKeys.get(tag) ?? [];
+          existing.push(key);
+          tagToKeys.set(tag, existing);
+        }
+      }
+    }
+  }
+  const severityFilter = filters?.severities.length ? new Map(filters.severities.map((s) => [s.level, s.all])) : void 0;
+  const categoryFilter = filters?.categories.length ? new Map(filters.categories.map((c) => [c.category, c.all])) : void 0;
+  const result = [];
+  for (const pattern of patterns) {
+    const matchedKeys = findMappedKeys(
+      pattern.id,
+      pattern.tags,
+      allMappedPrefixes,
+      prefixToKeys,
+      allMappedTags,
+      tagToKeys
+    );
+    if (matchedKeys.length > 0) {
+      if (!matchedKeys.some((k) => detectedKeys.has(k))) continue;
+    } else {
+      if (!pattern.enabled) {
+        if (!isOverriddenByAllPrefix(pattern, severityFilter, categoryFilter)) {
+          continue;
+        }
+      }
+    }
+    if (pattern.languages.length > 0 && repoLanguages.size > 0) {
+      if (!pattern.languages.some((lang) => repoLanguages.has(lang))) continue;
+    }
+    if (severityFilter && !severityFilter.has(pattern.severityLevel)) continue;
+    if (categoryFilter && !categoryFilter.has(pattern.category)) continue;
+    result.push(pattern);
+  }
+  return result;
+}
+function findMappedKeys(patternId, patternTags, allPrefixes, prefixToKeys, allTags, tagToKeys) {
+  const matched = /* @__PURE__ */ new Set();
+  let longestPrefix = "";
+  for (const prefix of allPrefixes) {
+    if (patternId.startsWith(prefix) && prefix.length > longestPrefix.length) {
+      longestPrefix = prefix;
+    }
+  }
+  if (longestPrefix) {
+    const keys = prefixToKeys.get(longestPrefix);
+    if (keys) for (const k of keys) matched.add(k);
+  }
+  if (patternTags && patternTags.length > 0 && allTags.length > 0) {
+    for (const tag of patternTags) {
+      const keys = tagToKeys.get(tag);
+      if (keys) for (const k of keys) matched.add(k);
+    }
+  }
+  return Array.from(matched);
+}
+function isOverriddenByAllPrefix(pattern, severityFilter, categoryFilter) {
+  if (severityFilter) {
+    const allFlag = severityFilter.get(pattern.severityLevel);
+    if (allFlag === true) return true;
+  }
+  if (categoryFilter) {
+    const allFlag = categoryFilter.get(pattern.category);
+    if (allFlag === true) return true;
+  }
+  return false;
+}
+
+// src/auto-filters.ts
+var SEVERITY_ALIASES = {
+  info: "Info",
+  minor: "Info",
+  warning: "Warning",
+  medium: "Warning",
+  high: "High",
+  error: "Error",
+  critical: "Error"
+};
+var CATEGORY_NAMES = {
+  security: "Security",
+  errorprone: "ErrorProne",
+  codestyle: "CodeStyle",
+  compatibility: "Compatibility",
+  performance: "Performance",
+  unusedcode: "UnusedCode",
+  complexity: "Complexity",
+  comprehensibility: "Comprehensibility",
+  bestpractice: "BestPractice",
+  documentation: "Documentation"
+};
+function parseAutoFilters(raw) {
+  const severities = [];
+  const categories = [];
+  const unknown = [];
+  const tokens = raw.split(",").map((t) => t.trim()).filter(Boolean);
+  for (const token of tokens) {
+    let name = token;
+    let all = false;
+    if (name.toLowerCase().startsWith("all")) {
+      all = true;
+      name = name.slice(3);
+    }
+    const severityMatch = SEVERITY_ALIASES[name.toLowerCase()];
+    if (severityMatch) {
+      if (!severities.some((s) => s.level === severityMatch)) {
+        severities.push({ level: severityMatch, all });
+      } else {
+        const existing = severities.find((s) => s.level === severityMatch);
+        if (all) existing.all = true;
+      }
+      continue;
+    }
+    const categoryMatch = CATEGORY_NAMES[name.toLowerCase()];
+    if (categoryMatch) {
+      if (!categories.some((c) => c.category === categoryMatch)) {
+        categories.push({ category: categoryMatch, all });
+      } else {
+        const existing = categories.find((c) => c.category === categoryMatch);
+        if (all) existing.all = true;
+      }
+      continue;
+    }
+    unknown.push(token);
+  }
+  return { filters: { severities, categories }, unknown };
+}
 
 // src/logger.ts
 var import_fs = __toESM(require("fs"));
-var import_path7 = __toESM(require("path"));
+var import_path8 = __toESM(require("path"));
 var import_os2 = __toESM(require("os"));
 var LEVEL_ORDER = {
   debug: 0,
@@ -5173,7 +6336,7 @@ function rotateLogFiles(logsDir, maxFiles) {
   const toRemove = entries2.slice(0, entries2.length - maxFiles);
   for (const f of toRemove) {
     try {
-      import_fs.default.unlinkSync(import_path7.default.join(logsDir, f));
+      import_fs.default.unlinkSync(import_path8.default.join(logsDir, f));
     } catch {
     }
   }
@@ -5208,7 +6371,7 @@ function enrichMessage(message, fields) {
 function createLogger(options = {}) {
   const minLevel = LEVEL_ORDER[options.level ?? "info"];
   const fileEnabled = options.fileEnabled ?? true;
-  const logsDir = options.logsDir ?? import_path7.default.join(import_os2.default.homedir(), ".codacy", "logs");
+  const logsDir = options.logsDir ?? import_path8.default.join(import_os2.default.homedir(), ".codacy", "logs");
   const maxFileSize = options.maxFileSize ?? 10 * 1024 * 1024;
   const maxFiles = options.maxFiles ?? 5;
   const onStderrMessage = options.onStderrMessage;
@@ -5217,7 +6380,7 @@ function createLogger(options = {}) {
   if (fileEnabled) {
     import_fs.default.mkdirSync(logsDir, { recursive: true });
     rotateLogFiles(logsDir, maxFiles);
-    const logFilePath = import_path7.default.join(logsDir, `analysis-${fileTimestamp()}.log`);
+    const logFilePath = import_path8.default.join(logsDir, `analysis-${fileTimestamp()}.log`);
     logFd = import_fs.default.openSync(logFilePath, "a");
   }
   function log(level, message, fields) {
@@ -5236,7 +6399,7 @@ function createLogger(options = {}) {
       if (bytesWritten >= maxFileSize) {
         import_fs.default.closeSync(logFd);
         rotateLogFiles(logsDir, maxFiles);
-        const newPath = import_path7.default.join(logsDir, `analysis-${fileTimestamp()}.log`);
+        const newPath = import_path8.default.join(logsDir, `analysis-${fileTimestamp()}.log`);
         logFd = import_fs.default.openSync(newPath, "a");
         bytesWritten = 0;
       }
@@ -5262,15 +6425,18 @@ function createLogger(options = {}) {
   applyCodacyYamlExcludes,
   buildToolConfig,
   clearAdapters,
+  computePatternSummary,
   configureApiToken,
   createCodacyConfig,
   createLogger,
   detectLanguages,
+  discover,
   formatOutput,
   formatTextSummary,
   getAdapter,
   getRegisteredAdapters,
   getRegisteredDescriptors,
+  initAutoConfig,
   initContainerConfig,
   initDefaultConfig,
   initLocalConfig,
@@ -5279,6 +6445,7 @@ function createLogger(options = {}) {
   listIgnoredFiles,
   listPrFiles,
   listStagedFiles,
+  parseAutoFilters,
   readCodacyConfig,
   readCodacyYaml,
   registerAdapter,