forgehive 1.0.2 → 1.0.3

package/dist/cli.js

@@ -3149,82 +3149,243 @@ import { createInterface as createInterface2 } from "node:readline";
 import fs from "node:fs";
 import path from "node:path";
 var TIER1 = [
+  // JavaScript / Node
   "package.json",
+  // Python
   "pyproject.toml",
+  "requirements.txt",
+  "Pipfile",
+  "setup.py",
+  "setup.cfg",
+  // Rust
   "Cargo.toml",
+  // Go
   "go.mod",
+  // Java / Kotlin
   "pom.xml",
+  "build.gradle",
+  "build.gradle.kts",
+  "settings.gradle",
+  "settings.gradle.kts",
+  // Ruby
   "Gemfile",
+  // PHP
   "composer.json",
+  // .NET
   "global.json",
-  "Directory.Build.props"
+  "Directory.Build.props",
+  // Swift / Apple
+  "Package.swift",
+  "Podfile",
+  "Cartfile",
+  // Dart / Flutter
+  "pubspec.yaml",
+  // Elixir
+  "mix.exs",
+  // Scala
+  "build.sbt",
+  // Clojure
+  "deps.edn",
+  "project.clj",
+  // C / C++
+  "CMakeLists.txt",
+  "conanfile.txt",
+  "conanfile.py",
+  "vcpkg.json",
+  // Crystal
+  "shard.yml",
+  // Lua
+  "rockspec",
+  // Zig
+  "build.zig",
+  // Perl
+  "cpanfile",
+  "Makefile.PL",
+  // Terraform (root-level)
+  "terraform.tfvars",
+  "main.tf"
 ];
 var TIER2_FILES = [
+  // Containers
   "Dockerfile",
   "docker-compose.yml",
-  ".gitlab-ci.yml"
+  "docker-compose.yaml",
+  // CI/CD
+  ".gitlab-ci.yml",
+  ".travis.yml",
+  "Jenkinsfile",
+  "circle.yml",
+  ".circleci/config.yml",
+  "azure-pipelines.yml",
+  "bitbucket-pipelines.yml",
+  // Hosting / Deploy
+  "netlify.toml",
+  "vercel.json",
+  "fly.toml",
+  "render.yaml",
+  "heroku.yml",
+  "app.yaml",
+  "appspec.yml",
+  // Config / Ops
+  "Vagrantfile",
+  "ansible.cfg",
+  ".envrc"
 ];
 var TIER2_DIRS = [
   ".github/workflows",
   "terraform",
-  "k8s"
+  "k8s",
+  ".circleci",
+  "ansible",
+  "charts",
+  "helm",
+  "pulumi",
+  "cdk"
 ];
 var TIER3_PATTERNS = [
+  // JavaScript tooling
   /^\.eslintrc(\.(json|js|yml|yaml|cjs))?$/,
+  /^eslint\.config\.(js|mjs|cjs|ts)$/,
   /^jest\.config\.(js|ts|mjs|cjs|json)$/,
   /^vitest\.config\.(js|ts|mjs)$/,
+  /^vite\.config\.(js|ts|mjs|cjs)$/,
+  /^webpack\.config\.(js|ts|mjs|cjs)$/,
+  /^next\.config\.(js|ts|mjs|cjs)$/,
+  /^nuxt\.config\.(js|ts|mjs)$/,
+  /^astro\.config\.(js|ts|mjs)$/,
+  /^svelte\.config\.(js|ts|mjs)$/,
+  /^remix\.config\.(js|ts|mjs)$/,
+  /^tailwind\.config\.(js|ts|mjs|cjs)$/,
+  /^postcss\.config\.(js|ts|mjs|cjs)$/,
+  /^\.babelrc(\.(json|js|ts))?$/,
+  /^babel\.config\.(js|json|ts|mjs)$/,
+  /^drizzle\.config\.(js|ts|mjs)$/,
+  /^tsconfig.*\.json$/,
+  /^\.prettierrc(\.(json|js|yml|yaml|ts))?$/,
+  /^prettier\.config\.(js|mjs|cjs|ts)$/,
+  /^playwright\.config\.(js|ts|mjs)$/,
+  /^cypress\.config\.(js|ts|mjs|cjs)$/,
+  // Python tooling
   /^pytest\.ini$/,
+  /^tox\.ini$/,
+  /^mypy\.ini$/,
+  /^\.mypy\.ini$/,
+  /^\.flake8$/,
+  /^\.pylintrc$/,
+  /^ruff\.toml$/,
+  // Ruby tooling
+  /^\.rubocop\.yml$/,
+  /^Rakefile$/,
+  /^Guardfile$/,
+  // Go tooling
+  /^\.golangci\.yml$/,
+  /^\.golangci\.yaml$/,
+  // Java tooling
+  /^gradlew$/,
+  /^mvnw$/,
+  /^\.java-version$/,
+  /^checkstyle\.xml$/,
+  /^spotbugs-filter\.xml$/,
+  // Version managers
+  /^\.ruby-version$/,
+  /^\.python-version$/,
+  /^\.node-version$/,
+  /^\.nvmrc$/,
+  /^\.tool-versions$/,
+  // API / Spec
   /^openapi\.(yaml|yml|json)$/,
-  /^\.pre-commit-config\.yaml$/
+  /^swagger\.(yaml|yml|json)$/,
+  /^graphql\.config\.(js|ts|yml|yaml|json)$/,
+  /^schema\.graphql$/,
+  /^\.graphqlrc(\.(json|js|yml|yaml))?$/,
+  // Infra
+  /^\.pre-commit-config\.yaml$/,
+  /^\.editorconfig$/,
+  /^sonar-project\.properties$/,
+  /^\.hadolint\.yaml$/,
+  // Prisma
+  /^schema\.prisma$/
 ];
 var DOTNET_EXTENSIONS = [".sln", ".csproj", ".fsproj", ".vbproj"];
+var SWIFT_EXTENSIONS = [".xcodeproj", ".xcworkspace"];
 function scan(projectRoot2) {
   const signals = [];
+  const seenPaths = /* @__PURE__ */ new Set();
+  const addSignal = (tier, filePath, filename) => {
+    if (seenPaths.has(filePath)) return;
+    seenPaths.add(filePath);
+    signals.push(signal(tier, filePath, filename));
+  };
   for (const filename of TIER1) {
     if (fs.existsSync(path.join(projectRoot2, filename))) {
-      signals.push(signal(1, filename, filename));
+      addSignal(1, filename, filename);
     }
   }
   for (const filename of TIER2_FILES) {
     if (fs.existsSync(path.join(projectRoot2, filename))) {
-      signals.push(signal(2, filename, path.basename(filename)));
+      addSignal(2, filename, path.basename(filename));
     }
   }
   for (const dir of TIER2_DIRS) {
     const abs = path.join(projectRoot2, dir);
     if (!fs.existsSync(abs) || !fs.statSync(abs).isDirectory()) continue;
-    for (const child of fs.readdirSync(abs)) {
-      const rel = path.join(dir, child);
-      signals.push(signal(2, rel, child));
+    try {
+      for (const child of fs.readdirSync(abs)) {
+        const rel = path.join(dir, child);
+        addSignal(2, rel, child);
+      }
+    } catch {
     }
   }
-  for (const entry of fs.readdirSync(projectRoot2)) {
-    const abs = path.join(projectRoot2, entry);
-    if (!fs.statSync(abs).isFile()) continue;
-    for (const pattern of TIER3_PATTERNS) {
-      if (pattern.test(entry)) {
-        signals.push(signal(3, entry, entry));
-        break;
+  try {
+    for (const entry of fs.readdirSync(projectRoot2)) {
+      const abs = path.join(projectRoot2, entry);
+      if (!fs.statSync(abs).isFile()) continue;
+      for (const pattern of TIER3_PATTERNS) {
+        if (pattern.test(entry)) {
+          addSignal(3, entry, entry);
+          break;
+        }
       }
+      const ext = path.extname(entry).toLowerCase();
+      if (DOTNET_EXTENSIONS.includes(ext)) addSignal(1, entry, entry);
+      if (SWIFT_EXTENSIONS.includes(ext)) addSignal(1, entry, entry);
+      if (entry.endsWith(".nimble")) addSignal(1, entry, entry);
     }
-    const ext = path.extname(entry).toLowerCase();
-    if (DOTNET_EXTENSIONS.includes(ext)) {
-      signals.push(signal(1, entry, entry));
-    }
+  } catch {
   }
-  for (const entry of fs.readdirSync(projectRoot2)) {
-    const abs = path.join(projectRoot2, entry);
-    if (!fs.existsSync(abs) || !fs.statSync(abs).isDirectory()) continue;
-    try {
-      for (const child of fs.readdirSync(abs)) {
-        const ext = path.extname(child).toLowerCase();
-        if ([".csproj", ".fsproj", ".vbproj"].includes(ext)) {
+  try {
+    for (const entry of fs.readdirSync(projectRoot2)) {
+      const abs = path.join(projectRoot2, entry);
+      if (!fs.existsSync(abs) || !fs.statSync(abs).isDirectory()) continue;
+      try {
+        for (const child of fs.readdirSync(abs)) {
+          const childAbs = path.join(abs, child);
+          const ext = path.extname(child).toLowerCase();
           const rel = path.join(entry, child);
-          signals.push(signal(1, rel, child));
+          if ([".csproj", ".fsproj", ".vbproj"].includes(ext)) {
+            addSignal(1, rel, child);
+          }
+          if (SWIFT_EXTENSIONS.includes(ext)) {
+            addSignal(1, rel, child);
+          }
+          if (child === "schema.prisma") {
+            addSignal(3, rel, child);
+          }
+          for (const pattern of TIER3_PATTERNS) {
+            if (pattern.test(child) && !seenPaths.has(rel)) {
+              try {
+                if (fs.statSync(childAbs).isFile()) addSignal(3, rel, child);
+              } catch {
+              }
+              break;
+            }
+          }
         }
+      } catch {
       }
-    } catch {
     }
+  } catch {
   }
   return {
     scanned_at: (/* @__PURE__ */ new Date()).toISOString(),
@@ -3234,39 +3395,145 @@ function scan(projectRoot2) {
   };
 }
 function extractPackages(projectRoot2) {
+  const packages = /* @__PURE__ */ new Set();
+  addAll(packages, extractNodePackages(projectRoot2));
+  addAll(packages, extractPythonPackages(projectRoot2));
+  addAll(packages, extractDotnetPackages(projectRoot2));
+  addAll(packages, extractRubyPackages(projectRoot2));
+  addAll(packages, extractGradlePackages(projectRoot2));
+  addAll(packages, extractDartPackages(projectRoot2));
+  addAll(packages, extractCargoPackages(projectRoot2));
+  addAll(packages, extractGoPackages(projectRoot2));
+  addAll(packages, extractElixirPackages(projectRoot2));
+  return [...packages];
+}
+function addAll(set2, items) {
+  for (const item of items) set2.add(item);
+}
+function extractNodePackages(projectRoot2) {
   const pkgPath = path.join(projectRoot2, "package.json");
-  if (fs.existsSync(pkgPath)) {
+  if (!fs.existsSync(pkgPath)) return [];
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    return [
+      ...Object.keys(pkg.dependencies ?? {}),
+      ...Object.keys(pkg.devDependencies ?? {}),
+      ...Object.keys(pkg.peerDependencies ?? {})
+    ];
+  } catch {
+    return [];
+  }
+}
+function extractPythonPackages(projectRoot2) {
+  const packages = [];
+  const reqPath = path.join(projectRoot2, "requirements.txt");
+  if (fs.existsSync(reqPath)) {
     try {
-      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-      const all = /* @__PURE__ */ new Set([
-        ...Object.keys(pkg.dependencies ?? {}),
-        ...Object.keys(pkg.devDependencies ?? {})
-      ]);
-      return [...all];
+      for (const line of fs.readFileSync(reqPath, "utf8").split("\n")) {
+        const clean = line.trim().split(/[>=<!;\[#]/)[0].trim();
+        if (clean && !clean.startsWith("-")) packages.push(clean);
+      }
+    } catch {
+    }
+  }
+  const pyprojectPath = path.join(projectRoot2, "pyproject.toml");
+  if (fs.existsSync(pyprojectPath)) {
+    try {
+      const content = fs.readFileSync(pyprojectPath, "utf8");
+      for (const match of content.matchAll(/^\s*"?([a-zA-Z0-9_\-]+)[>=<!\s"]/gm)) {
+        const name = match[1].trim();
+        if (name && name !== "python") packages.push(name);
+      }
+    } catch {
+    }
+  }
+  const pipfilePath = path.join(projectRoot2, "Pipfile");
+  if (fs.existsSync(pipfilePath)) {
+    try {
+      const content = fs.readFileSync(pipfilePath, "utf8");
+      for (const match of content.matchAll(/^([a-zA-Z0-9_\-]+)\s*=/gm)) {
+        const name = match[1].trim();
+        if (name && !["source", "requires"].includes(name)) packages.push(name);
+      }
+    } catch {
+    }
+  }
+  return packages;
+}
+function extractRubyPackages(projectRoot2) {
+  const gemfilePath = path.join(projectRoot2, "Gemfile");
+  if (!fs.existsSync(gemfilePath)) return [];
+  const packages = [];
+  try {
+    const content = fs.readFileSync(gemfilePath, "utf8");
+    for (const match of content.matchAll(/^\s*gem\s+['"]([^'"]+)['"]/gm)) {
+      packages.push(match[1]);
+    }
+  } catch {
+  }
+  return packages;
+}
+function extractGradlePackages(projectRoot2) {
+  const packages = [];
+  const gradleFiles = ["build.gradle", "build.gradle.kts"];
+  for (const file of gradleFiles) {
+    const p = path.join(projectRoot2, file);
+    if (!fs.existsSync(p)) continue;
+    try {
+      const content = fs.readFileSync(p, "utf8");
+      for (const match of content.matchAll(/['"]([a-zA-Z0-9._\-]+):([a-zA-Z0-9._\-]+):[^'"]+['"]/g)) {
+        packages.push(`${match[1]}:${match[2]}`);
+      }
     } catch {
-      return [];
     }
   }
-  return extractDotnetPackages(projectRoot2);
+  return packages;
+}
+function extractDartPackages(projectRoot2) {
+  const pubspecPath = path.join(projectRoot2, "pubspec.yaml");
+  if (!fs.existsSync(pubspecPath)) return [];
+  const packages = [];
+  try {
+    const content = fs.readFileSync(pubspecPath, "utf8");
+    let inDeps = false;
+    for (const line of content.split("\n")) {
+      if (/^(dependencies|dev_dependencies|dependency_overrides)\s*:/.test(line)) {
+        inDeps = true;
+        continue;
+      }
+      if (inDeps && /^\S/.test(line) && !line.startsWith(" ")) {
+        inDeps = false;
+      }
+      if (inDeps) {
+        const match = line.match(/^\s{2}([a-zA-Z0-9_]+)\s*:/);
+        if (match && match[1] !== "sdk") packages.push(match[1]);
+      }
+    }
+  } catch {
+  }
+  return packages;
 }
 function extractDotnetPackages(projectRoot2) {
   const packages = /* @__PURE__ */ new Set();
   const pattern = /PackageReference\s+Include="([^"]+)"/gi;
-  const scanDir = (dir) => {
+  const scanDir = (dir, depth = 0) => {
+    if (depth > 3) return;
     try {
       for (const entry of fs.readdirSync(dir)) {
+        if (entry.startsWith(".") || entry === "node_modules") continue;
         const abs = path.join(dir, entry);
         const ext = path.extname(entry).toLowerCase();
         if ([".csproj", ".fsproj", ".vbproj"].includes(ext)) {
           try {
             const content = fs.readFileSync(abs, "utf8");
-            for (const match of content.matchAll(pattern)) {
-              packages.add(match[1]);
-            }
+            for (const match of content.matchAll(pattern)) packages.add(match[1]);
+          } catch {
+          }
+        } else {
+          try {
+            if (fs.statSync(abs).isDirectory()) scanDir(abs, depth + 1);
           } catch {
           }
-        } else if (fs.statSync(abs).isDirectory() && !entry.startsWith(".")) {
-          scanDir(abs);
         }
       }
     } catch {
@@ -3275,143 +3542,790 @@ function extractDotnetPackages(projectRoot2) {
   scanDir(projectRoot2);
   return [...packages];
 }
+function extractCargoPackages(projectRoot2) {
+  const cargoPath = path.join(projectRoot2, "Cargo.toml");
+  if (!fs.existsSync(cargoPath)) return [];
+  const packages = [];
+  try {
+    const content = fs.readFileSync(cargoPath, "utf8");
+    let inDeps = false;
+    for (const line of content.split("\n")) {
+      if (/^\[(dependencies|dev-dependencies|build-dependencies)\]/.test(line)) {
+        inDeps = true;
+        continue;
+      }
+      if (inDeps && line.startsWith("[")) {
+        inDeps = false;
+      }
+      if (inDeps) {
+        const match = line.match(/^([a-zA-Z0-9_\-]+)\s*=/);
+        if (match) packages.push(match[1]);
+      }
+    }
+  } catch {
+  }
+  return packages;
+}
+function extractGoPackages(projectRoot2) {
+  const gomodPath = path.join(projectRoot2, "go.mod");
+  if (!fs.existsSync(gomodPath)) return [];
+  const packages = [];
+  try {
+    const content = fs.readFileSync(gomodPath, "utf8");
+    let inRequire = false;
+    for (const line of content.split("\n")) {
+      if (/^require\s+\(/.test(line)) {
+        inRequire = true;
+        continue;
+      }
+      if (inRequire && line.trim() === ")") {
+        inRequire = false;
+        continue;
+      }
+      const singleMatch = line.match(/^require\s+(\S+)/);
+      if (singleMatch) {
+        packages.push(singleMatch[1]);
+        continue;
+      }
+      if (inRequire) {
+        const match = line.trim().match(/^(\S+)/);
+        if (match && !match[1].startsWith("//")) packages.push(match[1]);
+      }
+    }
+  } catch {
+  }
+  return packages;
+}
+function extractElixirPackages(projectRoot2) {
+  const mixPath = path.join(projectRoot2, "mix.exs");
+  if (!fs.existsSync(mixPath)) return [];
+  const packages = [];
+  try {
+    const content = fs.readFileSync(mixPath, "utf8");
+    for (const match of content.matchAll(/\{:([a-zA-Z0-9_]+)/g)) {
+      packages.push(match[1]);
+    }
+  } catch {
+  }
+  return packages;
+}
 function signal(tier, filePath, filename) {
   return { tier, path: filePath, filename, exists: true };
 }
 
 // src/lookup-table.ts
 var FILENAME_TO_IDS = {
+  // JavaScript / Node
   "package.json": ["nodejs", "javascript"],
+  // Python
   "pyproject.toml": ["python"],
-  "Cargo.toml": ["rust"],
+  "requirements.txt": ["python", "pip"],
+  "Pipfile": ["python", "pipenv"],
+  "setup.py": ["python", "pip"],
+  "setup.cfg": ["python"],
+  // Rust
+  "Cargo.toml": ["rust", "cargo"],
+  // Go
   "go.mod": ["golang"],
+  // Java / Kotlin / JVM
   "pom.xml": ["java", "maven"],
-  "Gemfile": ["ruby"],
-  "composer.json": ["php"],
+  "build.gradle": ["java", "gradle"],
+  "build.gradle.kts": ["kotlin", "gradle"],
+  "settings.gradle": ["java", "gradle"],
+  "settings.gradle.kts": ["kotlin", "gradle"],
+  // Ruby
+  "Gemfile": ["ruby", "bundler"],
+  // PHP
+  "composer.json": ["php", "composer"],
+  // .NET
   "global.json": ["dotnet"],
   "Directory.Build.props": ["dotnet"],
+  // Swift / Apple
+  "Package.swift": ["swift", "spm"],
+  "Podfile": ["swift", "cocoapods"],
+  "Cartfile": ["swift", "carthage"],
+  // Dart / Flutter
+  "pubspec.yaml": ["dart", "flutter"],
+  // Elixir
+  "mix.exs": ["elixir", "mix"],
+  // Scala
+  "build.sbt": ["scala", "sbt"],
+  // Clojure
+  "deps.edn": ["clojure"],
+  "project.clj": ["clojure", "leiningen"],
+  // C / C++
+  "CMakeLists.txt": ["cmake", "cpp"],
+  "conanfile.txt": ["conan", "cpp"],
+  "conanfile.py": ["conan", "cpp"],
+  "vcpkg.json": ["vcpkg", "cpp"],
+  // Crystal
+  "shard.yml": ["crystal"],
+  // Zig
+  "build.zig": ["zig"],
+  // Perl
+  "cpanfile": ["perl"],
+  "Makefile.PL": ["perl"],
+  // Terraform
+  "main.tf": ["terraform", "infrastructure-as-code"],
+  "terraform.tfvars": ["terraform"],
+  // Containers
   "Dockerfile": ["docker"],
   "docker-compose.yml": ["docker-compose"],
+  "docker-compose.yaml": ["docker-compose"],
+  // CI/CD
   ".gitlab-ci.yml": ["gitlab-ci", "ci-cd"],
-  "pytest.ini": ["pytest"],
+  ".travis.yml": ["travis-ci", "ci-cd"],
+  "Jenkinsfile": ["jenkins", "ci-cd"],
+  "azure-pipelines.yml": ["azure-devops", "ci-cd"],
+  "bitbucket-pipelines.yml": ["bitbucket", "ci-cd"],
+  "circle.yml": ["circleci", "ci-cd"],
+  // Hosting / Deploy
+  "netlify.toml": ["netlify"],
+  "vercel.json": ["vercel"],
+  "fly.toml": ["fly-io"],
+  "render.yaml": ["render"],
+  "heroku.yml": ["heroku"],
+  "app.yaml": ["gcp-app-engine"],
+  "appspec.yml": ["aws-codedeploy"],
+  // Ops
+  "Vagrantfile": ["vagrant"],
+  "ansible.cfg": ["ansible"],
+  ".envrc": ["direnv"],
+  // API / Schema
   "openapi.yaml": ["openapi"],
   "openapi.yml": ["openapi"],
   "openapi.json": ["openapi"],
-  ".pre-commit-config.yaml": ["pre-commit"]
+  "swagger.yaml": ["openapi", "swagger"],
+  "swagger.yml": ["openapi", "swagger"],
+  "swagger.json": ["openapi", "swagger"],
+  // Quality
+  ".pre-commit-config.yaml": ["pre-commit"],
+  "sonar-project.properties": ["sonarqube"],
+  // Python tooling
+  "pytest.ini": ["pytest"],
+  "tox.ini": ["tox"],
+  "mypy.ini": ["mypy"],
+  ".mypy.ini": ["mypy"],
+  ".flake8": ["flake8"],
+  ".pylintrc": ["pylint"],
+  "ruff.toml": ["ruff"],
+  // Ruby tooling
+  "Rakefile": ["rake"],
+  "Guardfile": ["guard"],
+  // Version managers
+  ".nvmrc": ["nodejs"],
+  ".node-version": ["nodejs"],
+  ".ruby-version": ["ruby"],
+  ".python-version": ["python"],
+  ".tool-versions": ["asdf"],
+  ".java-version": ["java"],
+  // Infra dirs (these are created as file signals from dir scans)
+  "ci.yml": ["github-actions", "ci-cd"],
+  "ci.yaml": ["github-actions", "ci-cd"],
+  "release.yml": ["github-actions", "ci-cd"],
+  "deploy.yml": ["github-actions", "ci-cd"]
 };
 var TIER2_DIR_PREFIX_TO_IDS = {
   ".github/workflows": ["github-actions", "ci-cd"],
+  ".circleci": ["circleci", "ci-cd"],
   "terraform": ["terraform", "infrastructure-as-code"],
-  "k8s": ["kubernetes"]
+  "k8s": ["kubernetes"],
+  "ansible": ["ansible"],
+  "charts": ["helm", "kubernetes"],
+  "helm": ["helm", "kubernetes"],
+  "pulumi": ["pulumi", "infrastructure-as-code"],
+  "cdk": ["aws-cdk", "infrastructure-as-code"]
 };
 var FILENAME_PREFIX_TO_IDS = [
+  // JS frameworks / tooling
   [/^jest\.config\./, ["jest", "unit-testing"]],
   [/^vitest\.config\./, ["vitest", "unit-testing"]],
+  [/^vite\.config\./, ["vite"]],
+  [/^webpack\.config\./, ["webpack"]],
+  [/^next\.config\./, ["nextjs"]],
+  [/^nuxt\.config\./, ["nuxt"]],
+  [/^astro\.config\./, ["astro"]],
+  [/^svelte\.config\./, ["svelte"]],
+  [/^remix\.config\./, ["remix"]],
+  [/^tailwind\.config\./, ["tailwind"]],
+  [/^postcss\.config\./, ["postcss"]],
   [/^\.eslintrc/, ["eslint", "linting"]],
+  [/^eslint\.config\./, ["eslint", "linting"]],
+  [/^\.babelrc/, ["babel"]],
+  [/^babel\.config\./, ["babel"]],
+  [/^drizzle\.config\./, ["drizzle", "orm"]],
+  [/^tsconfig.*\.json$/, ["typescript"]],
+  [/^\.prettierrc/, ["prettier"]],
+  [/^prettier\.config\./, ["prettier"]],
+  [/^playwright\.config\./, ["playwright", "e2e-testing"]],
+  [/^cypress\.config\./, ["cypress", "e2e-testing"]],
+  // Python
+  [/^ruff\.toml$/, ["ruff", "linting"]],
+  // Ruby
+  [/^\.rubocop\.yml$/, ["rubocop", "linting"]],
+  // Go
+  [/^\.golangci\.ya?ml$/, ["golangci", "linting"]],
+  // Java
+  [/^gradlew$/, ["gradle"]],
+  [/^mvnw$/, ["maven"]],
+  [/^checkstyle\.xml$/, ["checkstyle", "linting"]],
+  // .NET extensions
   [/\.sln$/i, ["dotnet", "csharp"]],
   [/\.csproj$/i, ["dotnet", "csharp", "nuget"]],
   [/\.fsproj$/i, ["dotnet", "fsharp", "nuget"]],
-  [/\.vbproj$/i, ["dotnet", "vbnet", "nuget"]]
+  [/\.vbproj$/i, ["dotnet", "vbnet", "nuget"]],
+  // Swift / Apple
+  [/\.xcodeproj$/i, ["swift", "xcode"]],
+  [/\.xcworkspace$/i, ["swift", "xcode"]],
+  // Nim
+  [/\.nimble$/i, ["nim"]],
+  // GraphQL
+  [/^\.graphqlrc/, ["graphql"]],
+  [/^graphql\.config\./, ["graphql"]],
+  [/^schema\.graphql$/, ["graphql"]],
+  [/^schema\.prisma$/, ["prisma", "orm"]],
+  // Misc
+  [/^\.editorconfig$/, ["editorconfig"]],
+  [/^\.hadolint\.ya?ml$/, ["hadolint", "docker"]],
+  [/^sonar-project\./, ["sonarqube"]]
 ];
 var PACKAGE_TO_IDS = {
-  // JS Frameworks
+  // ─── JavaScript / TypeScript Frameworks ──────────────────────────────────
   "react": ["react"],
   "react-dom": ["react"],
   "next": ["nextjs"],
   "nuxt": ["nuxt"],
+  "nuxt3": ["nuxt"],
   "vue": ["vue"],
   "@vue/core": ["vue"],
   "svelte": ["svelte"],
   "@sveltejs/kit": ["sveltekit"],
   "remix": ["remix"],
   "@remix-run/react": ["remix"],
+  "@remix-run/node": ["remix"],
   "gatsby": ["gatsby"],
   "astro": ["astro"],
-  // Backend JS
+  "qwik": ["qwik"],
+  "@builder.io/qwik": ["qwik"],
+  "solid-js": ["solidjs"],
+  "@angular/core": ["angular"],
+  "@angular/cli": ["angular"],
+  "ember-cli": ["ember"],
+  "ember-source": ["ember"],
+  // Backend JS/TS
   "express": ["express"],
   "fastify": ["fastify"],
   "hono": ["hono"],
   "koa": ["koa"],
-  "nestjs": ["nestjs"],
   "@nestjs/core": ["nestjs"],
+  "nestjs": ["nestjs"],
+  "@hapi/hapi": ["hapi"],
+  "restify": ["restify"],
+  "feathers": ["feathers"],
+  "@feathersjs/feathers": ["feathers"],
+  "socket.io": ["socket-io", "websockets"],
+  "ws": ["websockets"],
   // Database / ORM
-  "@prisma/client": ["prisma"],
-  "prisma": ["prisma"],
-  "drizzle-orm": ["drizzle"],
-  "typeorm": ["typeorm"],
-  "mongoose": ["mongoose"],
-  "sequelize": ["sequelize"],
+  "@prisma/client": ["prisma", "orm"],
+  "prisma": ["prisma", "orm"],
+  "drizzle-orm": ["drizzle", "orm"],
+  "typeorm": ["typeorm", "orm"],
+  "mongoose": ["mongoose", "mongodb"],
+  "sequelize": ["sequelize", "orm"],
+  "knex": ["knex", "orm"],
+  "mikro-orm": ["mikro-orm", "orm"],
+  "@mikro-orm/core": ["mikro-orm", "orm"],
+  "pg": ["postgresql"],
+  "postgres": ["postgresql"],
+  "@neondatabase/serverless": ["postgresql", "neon"],
+  "mysql2": ["mysql"],
+  "better-sqlite3": ["sqlite"],
+  "@libsql/client": ["turso", "sqlite"],
+  "ioredis": ["redis"],
+  "redis": ["redis"],
+  "mongodb": ["mongodb"],
+  "@elastic/elasticsearch": ["elasticsearch"],
   // Testing JS
-  "vitest": ["vitest"],
-  "jest": ["jest"],
-  "@playwright/test": ["playwright"],
-  "playwright": ["playwright"],
-  "cypress": ["cypress"],
+  "vitest": ["vitest", "unit-testing"],
+  "jest": ["jest", "unit-testing"],
+  "@jest/core": ["jest", "unit-testing"],
+  "mocha": ["mocha", "unit-testing"],
+  "chai": ["chai"],
+  "jasmine": ["jasmine"],
+  "@playwright/test": ["playwright", "e2e-testing"],
+  "playwright": ["playwright", "e2e-testing"],
+  "cypress": ["cypress", "e2e-testing"],
+  "puppeteer": ["puppeteer", "e2e-testing"],
   "storybook": ["storybook"],
   "@storybook/react": ["storybook"],
+  "msw": ["msw", "mocking"],
+  "sinon": ["sinon", "mocking"],
+  "@testing-library/react": ["testing-library"],
+  "@testing-library/vue": ["testing-library"],
   // Build / Tooling
   "vite": ["vite"],
   "webpack": ["webpack"],
   "esbuild": ["esbuild"],
+  "rollup": ["rollup"],
+  "parcel": ["parcel"],
   "turbo": ["turborepo"],
   "nx": ["nx"],
+  "lerna": ["lerna"],
+  "@swc/core": ["swc"],
+  "typescript": ["typescript"],
+  "tsx": ["typescript"],
+  "ts-node": ["typescript"],
   // Auth
-  "next-auth": ["next-auth"],
-  "@auth/core": ["auth-js"],
-  "lucia": ["lucia"],
+  "next-auth": ["next-auth", "auth"],
+  "@auth/core": ["auth-js", "auth"],
+  "lucia": ["lucia", "auth"],
+  "passport": ["passport", "auth"],
+  "jsonwebtoken": ["jwt", "auth"],
+  "jose": ["jwt", "auth"],
+  "bcrypt": ["bcrypt", "auth"],
+  "bcryptjs": ["bcrypt", "auth"],
+  "@clerk/nextjs": ["clerk", "auth"],
+  "@clerk/clerk-sdk-node": ["clerk", "auth"],
+  "better-auth": ["auth"],
   // Styling
   "tailwindcss": ["tailwind"],
   "@tailwindcss/vite": ["tailwind"],
   "styled-components": ["styled-components"],
+  "@emotion/react": ["emotion"],
+  "sass": ["sass"],
+  "less": ["less"],
+  "postcss": ["postcss"],
   // State
   "zustand": ["zustand"],
   "jotai": ["jotai"],
   "@reduxjs/toolkit": ["redux"],
   "redux": ["redux"],
-  // Python frameworks (from pip, often in pyproject.toml — detected via name in packages)
+  "mobx": ["mobx"],
+  "recoil": ["recoil"],
+  "xstate": ["xstate"],
+  "pinia": ["pinia"],
+  // Validation
+  "zod": ["zod", "validation"],
+  "yup": ["yup", "validation"],
+  "joi": ["joi", "validation"],
+  "valibot": ["valibot", "validation"],
+  // API / Query
+  "@tanstack/react-query": ["react-query"],
+  "react-query": ["react-query"],
+  "@tanstack/query-core": ["react-query"],
+  "@trpc/server": ["trpc"],
+  "@trpc/client": ["trpc"],
+  "graphql": ["graphql"],
+  "apollo-server": ["apollo", "graphql"],
+  "@apollo/server": ["apollo", "graphql"],
+  "@apollo/client": ["apollo", "graphql"],
+  "urql": ["urql", "graphql"],
+  "openapi-fetch": ["openapi"],
+  // AI / LLM
+  "@anthropic-ai/sdk": ["anthropic", "ai"],
+  "openai": ["openai", "ai"],
+  "@langchain/core": ["langchain", "ai"],
+  "langchain": ["langchain", "ai"],
+  "ai": ["vercel-ai", "ai"],
+  "@vercel/ai": ["vercel-ai", "ai"],
+  "@mistralai/mistralai": ["mistral", "ai"],
+  // Infra / Cloud JS
+  "serverless": ["serverless"],
+  "@aws-sdk/client-s3": ["aws-sdk", "aws"],
+  "@aws-sdk/client-dynamodb": ["aws-sdk", "aws", "dynamodb"],
+  "aws-lambda": ["aws-lambda", "aws"],
+  "@google-cloud/storage": ["gcp"],
+  "@azure/storage-blob": ["azure"],
+  // Observability
+  "@opentelemetry/api": ["opentelemetry"],
+  "pino": ["pino", "logging"],
+  "winston": ["winston", "logging"],
+  "dd-trace": ["datadog"],
+  // ─── Python packages ─────────────────────────────────────────────────────
   "fastapi": ["fastapi"],
   "django": ["django"],
   "flask": ["flask"],
-  "sqlalchemy": ["sqlalchemy"],
-  "pydantic": ["pydantic"],
-  "alembic": ["alembic"],
-  // .NET / NuGet packages
+  "starlette": ["starlette"],
+  "tornado": ["tornado"],
+  "aiohttp": ["aiohttp"],
+  "sanic": ["sanic"],
+  "litestar": ["litestar"],
+  "falcon": ["falcon"],
+  "bottle": ["bottle"],
+  "pyramid": ["pyramid"],
+  // Python ORM / DB
+  "sqlalchemy": ["sqlalchemy", "orm"],
+  "databases": ["databases"],
+  "tortoise-orm": ["tortoise-orm", "orm"],
+  "alembic": ["alembic", "migrations"],
+  "pydantic": ["pydantic", "validation"],
+  "pydantic-settings": ["pydantic"],
+  "pymongo": ["mongodb"],
+  "motor": ["mongodb", "async"],
+  "redis": ["redis"],
+  "aioredis": ["redis", "async"],
+  "psycopg2": ["postgresql"],
+  "psycopg2-binary": ["postgresql"],
+  "asyncpg": ["postgresql", "async"],
+  "aiomysql": ["mysql", "async"],
+  "elasticsearch": ["elasticsearch"],
+  "pymysql": ["mysql"],
+  // Python ML / Data Science / AI
+  "numpy": ["numpy", "data-science"],
+  "pandas": ["pandas", "data-science"],
+  "scipy": ["scipy", "data-science"],
+  "matplotlib": ["matplotlib", "data-science"],
+  "seaborn": ["seaborn", "data-science"],
+  "plotly": ["plotly", "data-science"],
+  "bokeh": ["bokeh"],
+  "altair": ["altair"],
+  "scikit-learn": ["scikit-learn", "ml"],
+  "sklearn": ["scikit-learn", "ml"],
+  "xgboost": ["xgboost", "ml"],
+  "lightgbm": ["lightgbm", "ml"],
+  "catboost": ["catboost", "ml"],
+  "tensorflow": ["tensorflow", "deep-learning"],
+  "tf-keras": ["tensorflow", "deep-learning"],
+  "keras": ["keras", "deep-learning"],
+  "torch": ["pytorch", "deep-learning"],
+  "torchvision": ["pytorch", "deep-learning"],
+  "torchaudio": ["pytorch", "deep-learning"],
+  "jax": ["jax", "deep-learning"],
+  "flax": ["jax", "deep-learning"],
+  "transformers": ["huggingface", "nlp", "deep-learning"],
+  "datasets": ["huggingface", "data-science"],
+  "huggingface-hub": ["huggingface"],
+  "diffusers": ["huggingface", "generative-ai"],
+  "sentence-transformers": ["sentence-transformers", "nlp"],
+  "spacy": ["spacy", "nlp"],
+  "nltk": ["nltk", "nlp"],
+  "gensim": ["gensim", "nlp"],
+  "langchain": ["langchain", "ai"],
+  "langchain-community": ["langchain", "ai"],
+  "langchain-core": ["langchain", "ai"],
+  "langchain-openai": ["langchain", "openai", "ai"],
+  "langchain-anthropic": ["langchain", "anthropic", "ai"],
+  "llama-index": ["llama-index", "ai"],
+  "llama_index": ["llama-index", "ai"],
+  "openai": ["openai", "ai"],
+  "anthropic": ["anthropic", "ai"],
+  "mistralai": ["mistral", "ai"],
+  "google-generativeai": ["gemini", "ai"],
+  "groq": ["groq", "ai"],
+  "together": ["together-ai", "ai"],
+  "chromadb": ["chromadb", "vector-db"],
+  "pinecone-client": ["pinecone", "vector-db"],
+  "weaviate-client": ["weaviate", "vector-db"],
+  "qdrant-client": ["qdrant", "vector-db"],
+  "faiss-cpu": ["faiss", "vector-db"],
+  "pymilvus": ["milvus", "vector-db"],
+  "opencv-python": ["opencv", "computer-vision"],
+  "pillow": ["pillow", "image-processing"],
+  "imageio": ["imageio"],
+  "librosa": ["librosa", "audio"],
+  // Python infra
+  "celery": ["celery", "task-queue"],
+  "dramatiq": ["dramatiq", "task-queue"],
+  "rq": ["rq", "task-queue"],
+  "boto3": ["aws-sdk", "aws"],
+  "botocore": ["aws-sdk", "aws"],
+  "google-cloud-storage": ["gcp"],
+  "azure-storage-blob": ["azure"],
+  "paramiko": ["ssh"],
+  "cryptography": ["cryptography"],
+  "pyjwt": ["jwt", "auth"],
+  "passlib": ["passlib", "auth"],
+  "python-jose": ["jwt", "auth"],
+  "httpx": ["httpx"],
+  "requests": ["requests"],
+  "aiohttp": ["aiohttp"],
+  "uvicorn": ["uvicorn", "asgi"],
+  "gunicorn": ["gunicorn", "wsgi"],
+  "hypercorn": ["hypercorn", "asgi"],
+  "loguru": ["loguru", "logging"],
+  "structlog": ["structlog", "logging"],
+  "opentelemetry-api": ["opentelemetry"],
+  "sentry-sdk": ["sentry"],
+  "pytest": ["pytest", "unit-testing"],
+  "pytest-asyncio": ["pytest", "unit-testing"],
+  "pytest-cov": ["pytest", "coverage"],
+  "mypy": ["mypy"],
+  "ruff": ["ruff"],
+  "black": ["black"],
+  "isort": ["isort"],
+  "click": ["click", "cli"],
+  "typer": ["typer", "cli"],
+  "rich": ["rich"],
+  "pydantic-v1": ["pydantic"],
+  // ─── Ruby gems ───────────────────────────────────────────────────────────
+  "rails": ["rails"],
+  "sinatra": ["sinatra"],
+  "grape": ["grape"],
+  "roda": ["roda"],
+  "hanami": ["hanami"],
+  "rspec-rails": ["rspec", "unit-testing"],
+  "rspec-core": ["rspec", "unit-testing"],
+  "minitest": ["minitest", "unit-testing"],
+  "capybara": ["capybara", "e2e-testing"],
+  "devise": ["devise", "auth"],
+  "doorkeeper": ["doorkeeper", "auth", "oauth"],
+  "sidekiq": ["sidekiq", "task-queue"],
+  "delayed_job": ["delayed-job", "task-queue"],
+  "active_record": ["activerecord", "orm"],
+  "sequel": ["sequel", "orm"],
+  "pg": ["postgresql"],
+  "mysql2": ["mysql"],
+  "redis": ["redis"],
+  "mongoid": ["mongodb"],
+  "factory_bot": ["factory-bot", "testing"],
+  "factory_bot_rails": ["factory-bot", "testing"],
+  "faker": ["faker", "testing"],
+  "pundit": ["pundit", "authorization"],
+  "cancancan": ["cancancan", "authorization"],
+  "kaminari": ["kaminari", "pagination"],
+  "pagy": ["pagy", "pagination"],
+  "puma": ["puma", "web-server"],
+  "unicorn": ["unicorn", "web-server"],
+  "rubocop": ["rubocop", "linting"],
+  "sorbet": ["sorbet", "types"],
+  "dry-rb": ["dry-rb"],
+  "rom-rb": ["rom-rb"],
+  // ─── Java / Kotlin (Gradle group:artifact) ────────────────────────────────
+  "org.springframework.boot:spring-boot-starter": ["spring-boot"],
+  "org.springframework.boot:spring-boot-starter-web": ["spring-boot", "spring-web"],
+  "org.springframework.boot:spring-boot-starter-data-jpa": ["spring-boot", "spring-data", "jpa"],
+  "org.springframework.boot:spring-boot-starter-security": ["spring-boot", "spring-security"],
+  "org.springframework.boot:spring-boot-starter-test": ["spring-boot", "junit"],
+  "org.springframework:spring-core": ["spring"],
+  "org.springframework:spring-web": ["spring-web"],
+  "org.hibernate.orm:hibernate-core": ["hibernate", "orm"],
+  "org.junit.jupiter:junit-jupiter": ["junit", "unit-testing"],
+  "junit:junit": ["junit", "unit-testing"],
+  "org.mockito:mockito-core": ["mockito", "mocking"],
+  "org.assertj:assertj-core": ["assertj"],
+  "com.fasterxml.jackson.core:jackson-databind": ["jackson", "json"],
+  "org.slf4j:slf4j-api": ["slf4j", "logging"],
+  "ch.qos.logback:logback-classic": ["logback", "logging"],
+  "org.apache.logging.log4j:log4j-core": ["log4j", "logging"],
+  "io.micrometer:micrometer-core": ["micrometer", "observability"],
+  "org.flywaydb:flyway-core": ["flyway", "migrations"],
+  "org.liquibase:liquibase-core": ["liquibase", "migrations"],
+  "com.querydsl:querydsl-jpa": ["querydsl"],
+  "org.mapstruct:mapstruct": ["mapstruct"],
+  "io.quarkus:quarkus-core": ["quarkus"],
+  "io.micronaut:micronaut-core": ["micronaut"],
+  "io.ktor:ktor-server-core": ["ktor", "kotlin"],
+  "org.jetbrains.kotlinx:kotlinx-coroutines-core": ["kotlin-coroutines"],
+  "org.jetbrains.kotlinx:kotlinx-serialization-json": ["kotlinx-serialization"],
+  "com.google.dagger:dagger": ["dagger", "di"],
+  "io.insert-koin:koin-core": ["koin", "di"],
+  // ─── Go modules (full module path) ───────────────────────────────────────
+  "github.com/gin-gonic/gin": ["gin"],
+  "github.com/labstack/echo/v4": ["echo"],
+  "github.com/gofiber/fiber/v2": ["fiber"],
+  "github.com/go-chi/chi/v5": ["chi"],
+  "github.com/gorilla/mux": ["gorilla-mux"],
+  "github.com/gin-gonic/gin/v2": ["gin"],
+  "google.golang.org/grpc": ["grpc"],
+  "github.com/grpc-ecosystem/grpc-gateway/v2": ["grpc-gateway", "grpc"],
+  "gorm.io/gorm": ["gorm", "orm"],
+  "github.com/jmoiern/sqlx": ["sqlx"],
+  "github.com/go-sql-driver/mysql": ["mysql"],
+  "github.com/lib/pq": ["postgresql"],
+  "github.com/jackc/pgx/v5": ["postgresql"],
+  "go.mongodb.org/mongo-driver": ["mongodb"],
+  "github.com/go-redis/redis/v8": ["redis"],
+  "github.com/redis/go-redis/v9": ["redis"],
+  "github.com/spf13/cobra": ["cobra", "cli"],
+  "github.com/spf13/viper": ["viper", "config"],
+  "github.com/sirupsen/logrus": ["logrus", "logging"],
+  "go.uber.org/zap": ["zap", "logging"],
+  "github.com/rs/zerolog": ["zerolog", "logging"],
+  "golang.org/x/oauth2": ["oauth2", "auth"],
+  "github.com/golang-jwt/jwt/v5": ["jwt", "auth"],
+  "github.com/stretchr/testify": ["testify", "unit-testing"],
+  "github.com/onsi/ginkgo/v2": ["ginkgo", "bdd-testing"],
+  "github.com/onsi/gomega": ["gomega"],
+  "github.com/go-playground/validator/v10": ["validator", "validation"],
+  "github.com/uber/fx": ["uber-fx", "di"],
+  "go.uber.org/dig": ["dig", "di"],
+  "github.com/nats-io/nats.go": ["nats", "messaging"],
+  "github.com/segmentio/kafka-go": ["kafka", "messaging"],
+  "go.opentelemetry.io/otel": ["opentelemetry"],
+  "github.com/prometheus/client_golang": ["prometheus"],
+  "cloud.google.com/go": ["gcp"],
+  "github.com/aws/aws-sdk-go-v2": ["aws-sdk", "aws"],
+  "github.com/hashicorp/terraform-plugin-sdk": ["terraform-plugin"],
+  // ─── Dart / Flutter packages ─────────────────────────────────────────────
+  "flutter": ["flutter"],
+  "flutter_test": ["flutter", "unit-testing"],
+  "provider": ["provider", "state-management"],
+  "riverpod": ["riverpod", "state-management"],
+  "flutter_riverpod": ["riverpod", "state-management"],
+  "hooks_riverpod": ["riverpod", "state-management"],
+  "bloc": ["bloc", "state-management"],
+  "flutter_bloc": ["bloc", "state-management"],
+  "get": ["getx", "state-management"],
+  "mobx": ["mobx", "state-management"],
+  "flutter_mobx": ["mobx", "state-management"],
+  "dio": ["dio", "http"],
+  "http": ["http"],
+  "retrofit": ["retrofit"],
+  "get_it": ["get-it", "di"],
+  "injectable": ["injectable", "di"],
+  "shared_preferences": ["shared-preferences", "storage"],
+  "hive": ["hive", "storage"],
+  "sqflite": ["sqflite", "sqlite"],
+  "drift": ["drift", "orm"],
+  "isar": ["isar", "storage"],
+  "firebase_core": ["firebase"],
+  "firebase_auth": ["firebase", "auth"],
+  "cloud_firestore": ["firebase", "firestore"],
+  "firebase_messaging": ["firebase", "fcm"],
+  "google_sign_in": ["google-sign-in", "auth"],
+  "flutter_secure_storage": ["secure-storage"],
+  "go_router": ["go-router", "routing"],
+  "auto_route": ["auto-route", "routing"],
+  "freezed": ["freezed", "code-gen"],
+  "json_annotation": ["json-serializable"],
+  "mockito": ["mockito", "mocking"],
+  "mocktail": ["mocktail", "mocking"],
+  // ─── Elixir / Hex packages ───────────────────────────────────────────────
+  "phoenix": ["phoenix"],
+  "phoenix_live_view": ["phoenix", "liveview"],
+  "ecto": ["ecto", "orm"],
+  "ecto_sql": ["ecto", "orm"],
+  "postgrex": ["postgresql"],
+  "myxql": ["mysql"],
+  "oban": ["oban", "task-queue"],
+  "broadway": ["broadway", "messaging"],
+  "absinthe": ["absinthe", "graphql"],
+  "guardian": ["guardian", "auth"],
+  "pow": ["pow", "auth"],
+  "gettext": ["gettext", "i18n"],
+  "ex_unit": ["exunit", "unit-testing"],
+  "ex_machina": ["ex-machina", "testing"],
+  "mox": ["mox", "mocking"],
+  "credo": ["credo", "linting"],
+  "dialyxir": ["dialyxir"],
+  "telemetry": ["telemetry"],
+  "swoosh": ["swoosh", "email"],
+  "cachex": ["cachex", "cache"],
+  // ─── Rust crates ─────────────────────────────────────────────────────────
+  "tokio": ["tokio", "async"],
+  "async-std": ["async-std", "async"],
+  "actix-web": ["actix-web"],
+  "axum": ["axum"],
+  "warp": ["warp"],
+  "rocket": ["rocket"],
+  "poem": ["poem"],
+  "hyper": ["hyper", "http"],
+  "reqwest": ["reqwest", "http"],
+  "serde": ["serde", "serialization"],
+  "serde_json": ["serde", "json"],
+  "sqlx": ["sqlx", "orm"],
+  "diesel": ["diesel", "orm"],
+  "sea-orm": ["sea-orm", "orm"],
+  "clap": ["clap", "cli"],
+  "anyhow": ["anyhow", "error-handling"],
+  "thiserror": ["thiserror", "error-handling"],
+  "tracing": ["tracing", "logging"],
+  "log": ["log", "logging"],
+  "env_logger": ["env-logger", "logging"],
+  "rayon": ["rayon", "parallelism"],
+  "tonic": ["tonic", "grpc"],
+  "prost": ["prost", "protobuf"],
+  "redis": ["redis"],
+  "mongodb": ["mongodb"],
+  "aws-sdk-s3": ["aws-sdk", "aws"],
+  "opentelemetry": ["opentelemetry"],
+  "prometheus": ["prometheus"],
+  "testcontainers": ["testcontainers", "testing"],
+  "mockall": ["mockall", "mocking"],
+  "criterion": ["criterion", "benchmarking"],
+  "wasm-bindgen": ["wasm"],
+  "leptos": ["leptos"],
+  "dioxus": ["dioxus"],
+  "tauri": ["tauri"],
+  // ─── .NET / NuGet packages ───────────────────────────────────────────────
   "xunit": ["xunit", "unit-testing"],
+  "xunit.runner.visualstudio": ["xunit"],
   "NUnit": ["nunit", "unit-testing"],
+  "NUnit3TestAdapter": ["nunit"],
   "MSTest.TestFramework": ["mstest", "unit-testing"],
+  "MSTest.TestAdapter": ["mstest"],
   "Microsoft.NET.Test.Sdk": ["dotnet-test"],
   "Moq": ["moq", "mocking"],
   "NSubstitute": ["nsubstitute", "mocking"],
+  "FakeItEasy": ["fakeiteasy", "mocking"],
   "FluentAssertions": ["fluent-assertions"],
+  "Shouldly": ["shouldly"],
+  "Bogus": ["bogus", "testing"],
+  "AutoFixture": ["autofixture", "testing"],
+  "Respawn": ["respawn", "testing"],
   "CommunityToolkit.Mvvm": ["wpf", "mvvm"],
-  "Microsoft.Extensions.DependencyInjection": ["aspnet-di"],
+  "MahApps.Metro": ["wpf", "ui-framework"],
+  "MaterialDesignThemes": ["wpf", "ui-framework"],
+  "Avalonia": ["avalonia"],
+  "Uno.UI": ["uno-platform"],
+  "Microsoft.Maui.Controls": ["maui"],
+  "Blazorise": ["blazor"],
+  "Microsoft.AspNetCore.Components": ["blazor"],
   "Microsoft.AspNetCore.OpenApi": ["aspnet", "openapi"],
   "Swashbuckle.AspNetCore": ["aspnet", "swagger"],
   "Microsoft.EntityFrameworkCore": ["ef-core", "orm"],
-  "Npgsql.EntityFrameworkCore.PostgreSQL": ["ef-core", "postgresql"],
   "Microsoft.EntityFrameworkCore.SqlServer": ["ef-core", "sql-server"],
+  "Npgsql.EntityFrameworkCore.PostgreSQL": ["ef-core", "postgresql"],
+  "Pomelo.EntityFrameworkCore.MySql": ["ef-core", "mysql"],
+  "Microsoft.EntityFrameworkCore.Sqlite": ["ef-core", "sqlite"],
+  "MongoDB.Driver": ["mongodb"],
   "Dapper": ["dapper", "orm"],
+  "StackExchange.Redis": ["redis"],
+  "Elasticsearch.Net": ["elasticsearch"],
+  "NEST": ["elasticsearch"],
   "Serilog": ["serilog", "logging"],
+  "Serilog.AspNetCore": ["serilog", "logging"],
   "NLog": ["nlog", "logging"],
+  "log4net": ["log4net", "logging"],
+  "OpenTelemetry": ["opentelemetry"],
+  "OpenTelemetry.Exporter.Prometheus": ["opentelemetry", "prometheus"],
   "AutoMapper": ["automapper"],
   "MediatR": ["mediatr", "cqrs"],
-  "FluentValidation": ["fluent-validation"],
-  "Newtonsoft.Json": ["newtonsoft-json"],
+  "FluentValidation": ["fluent-validation", "validation"],
+  "FluentValidation.AspNetCore": ["fluent-validation"],
+  "Newtonsoft.Json": ["newtonsoft-json", "json"],
+  "System.Text.Json": ["json"],
   "CsvHelper": ["csvhelper"],
+  "EPPlus": ["epplus", "excel"],
+  "ClosedXML": ["closedxml", "excel"],
   "Polly": ["polly", "resilience"],
   "Hangfire": ["hangfire", "background-jobs"],
+  "Quartz": ["quartz", "scheduling"],
   "MassTransit": ["masstransit", "messaging"],
-  "StackExchange.Redis": ["redis"],
-  "MongoDB.Driver": ["mongodb"],
-  "AWSSDK.Core": ["aws-sdk"],
+  "RabbitMQ.Client": ["rabbitmq", "messaging"],
+  "Confluent.Kafka": ["kafka", "messaging"],
   "Azure.Identity": ["azure"],
+  "Azure.Storage.Blobs": ["azure", "storage"],
+  "AWSSDK.Core": ["aws-sdk", "aws"],
+  "AWSSDK.S3": ["aws-sdk", "aws", "s3"],
+  "Google.Cloud.Storage.V1": ["gcp", "storage"],
   "Microsoft.Identity.Web": ["azure", "auth"],
-  "Blazorise": ["blazor"],
-  "Microsoft.AspNetCore.Components": ["blazor"],
-  "Avalonia": ["avalonia"],
-  "Uno.UI": ["uno-platform"],
-  "MAUI": ["maui"],
-  "Microsoft.Maui.Controls": ["maui"]
+  "IdentityServer4": ["identityserver", "auth", "oauth"],
+  "Duende.IdentityServer": ["identityserver", "auth", "oauth"],
+  "Refit": ["refit", "http"],
+  "RestSharp": ["restsharp", "http"],
+  "Grpc.AspNetCore": ["grpc"],
+  "MessagePack": ["messagepack", "serialization"],
+  "protobuf-net": ["protobuf"],
+  "BenchmarkDotNet": ["benchmark"],
+  "Scrutor": ["scrutor", "di"],
+  "Autofac": ["autofac", "di"],
+  "Lamar": ["lamar", "di"],
+  "Carter": ["carter", "aspnet"],
+  "FastEndpoints": ["fastendpoints", "aspnet"],
+  "Ardalis.Result": ["ardalis"],
+  "ErrorOr": ["error-or"],
+  "OneOf": ["oneof"]
 };
 function mapSignalsToCapabilities(input) {
   const seen = /* @__PURE__ */ new Set();
@@ -3429,7 +4343,7 @@ function mapSignalsToCapabilities(input) {
   for (const pkg of input.packages) {
     const ids = PACKAGE_TO_IDS[pkg];
     if (ids) {
-      for (const id of ids) add(id, "package.json");
+      for (const id of ids) add(id, pkg);
     }
   }
   return { confirmed, inferred: [] };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forgehive",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Context-aware AI development environment — one binary, your stack.",
   "type": "module",
   "bin": {