@cyclonedx/cdxgen 11.0.2 → 11.0.4

package/README.md

@@ -37,7 +37,7 @@ Our philosophy:
 
 ## Documentation
 
-Please visit our [documentation site][docs-homepage] for detailed usage, tutorials, and support documentation.
+Please visit our [GPT app][cdxgen-gpt] or the [documentation site][docs-homepage] for detailed usage, tutorials, and support documentation.
 
 Sections include:
 
@@ -556,3 +556,4 @@ pnpm test
 [podman-github-rootless]: https://github.com/containers/podman/blob/master/docs/tutorials/rootless_tutorial.md
 [podman-github-remote]: https://github.com/containers/podman/blob/master/docs/tutorials/mac_win_client.md
 [swh-cdxgen]: https://archive.softwareheritage.org/browse/origin/?origin_url=https://github.com/CycloneDX/cdxgen
+[cdxgen-gpt]: https://chatgpt.com/g/g-673bfeb4037481919be8a2cd1bf868d2-cyclonedx-generator-cdxgen

package/data/component-tags.json

@@ -232,7 +232,8 @@
     "sbom": [
       {
         "test": [
-          "(junit|xmlunit|testng|chai|mocha|jest|test4j|xunit|coverlet|Test\\.Sdk)"
+          "(junit|xmlunit|testng|mocha|jest|test4j|xunit|coverlet|Test\\.Sdk)",
+          "^(chai)$"
         ]
       },
       {
@@ -244,7 +245,9 @@
       { "parse": ["(parser)"] },
       { "transform": ["(transformer)"] },
       { "telemetry": ["(OpenTelemetry)"] },
-      { "logging": ["(Microsoft\\.Extensions\\.Logging|Log4net)"] }
+      { "logging": ["(Microsoft\\.Extensions\\.Logging|Log4net)"] },
+      { "ml": ["^(llama|langchain|openai)", "(generativeai)"] },
+      { "devel": ["^(types-|typing-|virtualenv|ruff|poetry)"] }
     ],
     "obom": [
       {

package/data/frameworks-list.json

@@ -60,6 +60,9 @@
     "pkg:pypi/botocore",
     "pkg:pypi/boto3",
     "pkg:pypi/azure",
+    "pkg:pypi/langchain",
+    "pkg:pypi/llama",
+    "pkg:pypi/sqlalchemy",
     "vibora",
     "koa",
     "-sdk",

package/lib/cli/index.js

@@ -92,6 +92,7 @@ import {
   parseCljDep,
   parseCloudBuildData,
   parseCmakeLikeFile,
+  parseComposerJson,
   parseComposerLock,
   parseConanData,
   parseConanLockData,
@@ -240,11 +241,12 @@ const createDefaultParentComponent = (
       : dirname(path);
   const tmpA = dirNameStr.split(sep);
   dirNameStr = tmpA[tmpA.length - 1];
+  const compName = options.projectName || dirNameStr;
   const parentComponent = {
     group: options.projectGroup || "",
-    name: options.projectName || dirNameStr,
+    name: compName,
     version: `${options.projectVersion}` || "latest",
-    type: "application",
+    type: compName.endsWith(".tar") ? "container" : "application",
   };
   const ppurl = new PackageURL(
     type,
@@ -816,6 +818,7 @@ function addComponent(
   if (!isRootPkg) {
     const pkgIdentifier = parsePackageJsonName(pkg.name);
     const author = pkg.author || undefined;
+    const authors = pkg.authors || undefined;
     const publisher = pkg.publisher || undefined;
     let group = pkg.group || pkgIdentifier.scope;
     // Create empty group
@@ -868,6 +871,7 @@ function addComponent(
     }
     const component = {
       author,
+      authors,
       publisher,
       group,
       name,
@@ -919,6 +923,15 @@ function addComponent(
       component.authors = authorsList;
       delete component.author;
     }
+    // Downgrade authors section for < 1.5 :(
+    if (options.specVersion < 1.6) {
+      if (component?.authors?.length) {
+        component.author = component.authors
+          .map((a) => (a.email ? `${a.name} <${a.email}>` : a.name))
+          .join(",");
+      }
+      delete component.authors;
+    }
     // Retain any tags
     if (
       options.specVersion >= 1.6 &&
@@ -957,7 +970,6 @@ function determinePackageType(pkg) {
   // Retain the exact component type in certain cases.
   if (
     [
-      "application",
       "container",
       "platform",
       "operating-system",
@@ -972,6 +984,12 @@ function determinePackageType(pkg) {
   ) {
     return pkg.type;
   }
+  if (pkg.type === "application") {
+    if (pkg?.name?.endsWith(".tar")) {
+      return "container";
+    }
+    return pkg.type;
+  }
   if (pkg.purl) {
     try {
       const purl = PackageURL.fromString(pkg.purl);
@@ -2253,7 +2271,11 @@ export async function createNodejsBom(path, options) {
     }
   }
   const pkgJsonLockFile = getAllFiles(path, "package-lock.json", options);
-  const pkgJsonFile = getAllFiles(path, "package.json", options);
+  const pkgJsonFile = getAllFiles(
+    path,
+    `${options.multiProject ? "**/" : ""}package.json`,
+    options,
+  );
   const yarnLockFile = getAllFiles(path, "yarn.lock", options);
   const pnpmLockFile = getAllFiles(path, "pnpm-lock.yaml", options);
   if (
@@ -2265,7 +2287,7 @@ export async function createNodejsBom(path, options) {
   ) {
     let pkgMgr = "npm";
     const supPkgMgrs = ["npm", "yarn", "yarnpkg", "pnpm", "pnpx"];
-    const pkgData = JSON.parse(readFileSync(`${path}/package.json`, "utf8"));
+    const pkgData = JSON.parse(readFileSync(pkgJsonFile[0], "utf8"));
     const mgrData = pkgData.packageManager;
     let mgr = "";
     let installArgs = ["install"];
@@ -2281,9 +2303,10 @@ export async function createNodejsBom(path, options) {
         process.env[`${pkgMgr.toUpperCase()}_INSTALL_ARGS`].split(" ");
       installArgs = installArgs.concat(addArgs);
     }
-    console.log(`Executing '${pkgMgr} ${installArgs.join(" ")}' in`, path);
+    const basePath = dirname(pkgJsonFile[0]);
+    console.log(`Executing '${pkgMgr} ${installArgs.join(" ")}' in`, basePath);
     const result = spawnSync(pkgMgr, installArgs, {
-      cwd: path,
+      cwd: basePath,
       encoding: "utf-8",
       timeout: TIMEOUT_MS,
       maxBuffer: MAX_BUFFER,
@@ -4844,57 +4867,46 @@ export function createPHPBom(path, options) {
     options,
   );
   if (composerLockFiles.length) {
+    // Look for any root composer.json to capture the parentComponent
+    if (existsSync(join(path, "composer.json"))) {
+      const { moduleParent } = parseComposerJson(join(path, "composer.json"));
+      parentComponent = moduleParent;
+    }
     for (const f of composerLockFiles) {
       const basePath = dirname(f);
+      let moduleParent;
       if (DEBUG_MODE) {
         console.log(`Parsing ${f}`);
       }
-      let rootRequires = [];
-      // Is there a composer.json to find the parent component
-      if (
-        !Object.keys(parentComponent).length &&
-        existsSync(join(basePath, "composer.json"))
-      ) {
-        const composerData = JSON.parse(
-          readFileSync(join(basePath, "composer.json"), { encoding: "utf-8" }),
-        );
-        rootRequires = composerData.require;
-        const pkgName = composerData.name;
-        if (pkgName) {
-          parentComponent.group = dirname(pkgName);
-          if (parentComponent.group === ".") {
-            parentComponent.group = "";
-          }
-          parentComponent.name = basename(pkgName);
-          parentComponent.type = "application";
-          parentComponent.version = composerData.version || "latest";
-          parentComponent["bom-ref"] = decodeURIComponent(
-            new PackageURL(
-              "composer",
-              parentComponent.group,
-              parentComponent.name,
-              parentComponent.version,
-              null,
-              null,
-            ).toString(),
-          );
+      const rootRequires = [];
+      // Is there a composer.json to find the module parent component
+      if (existsSync(join(basePath, "composer.json"))) {
+        const retMap = parseComposerJson(join(basePath, "composer.json"));
+        moduleParent = retMap.moduleParent;
+        const rootRequires = retMap.rootRequires;
+        // Track all the modules in a mono-repo
+        if (!Object.keys(parentComponent).length) {
+          parentComponent = moduleParent;
+        } else {
+          parentComponent.components = parentComponent.components || [];
+          parentComponent.components.push(moduleParent);
         }
       }
       const retMap = parseComposerLock(f, rootRequires);
       if (retMap.pkgList?.length) {
         pkgList = pkgList.concat(retMap.pkgList);
       }
+      if (!moduleParent) {
+        moduleParent = createDefaultParentComponent(
+          basePath,
+          "composer",
+          options,
+        );
+      }
       if (retMap.dependenciesList) {
-        if (!Object.keys(parentComponent).length) {
-          parentComponent = createDefaultParentComponent(
-            path,
-            "composer",
-            options,
-          );
-        }
         // Complete the dependency tree by making parent component depend on the first level
         const pdependencies = {
-          ref: parentComponent["bom-ref"],
+          ref: moduleParent["bom-ref"],
           dependsOn: [
             ...new Set(retMap.rootList.map((p) => p["bom-ref"])),
           ].sort(),
@@ -4906,6 +4918,17 @@ export function createPHPBom(path, options) {
         );
       }
     }
+    // Complete the root dependency tree
+    if (parentComponent?.components?.length) {
+      const parentDependsOn = parentComponent.components.map(
+        (d) => d["bom-ref"],
+      );
+      dependencies = mergeDependencies(
+        [{ ref: parentComponent["bom-ref"], dependsOn: parentDependsOn }],
+        dependencies,
+        parentComponent,
+      );
+    }
     return buildBomNSData(options, pkgList, "composer", {
       src: path,
       filename: composerLockFiles.join(", "),
@@ -6052,7 +6075,6 @@ export async function createXBom(path, options) {
   } catch (err) {
     return undefined;
   }
-  // node.js - package.json
   if (
     existsSync(join(path, "package.json")) ||
     existsSync(join(path, "rush.json")) ||

package/lib/evinser/evinser.js

@@ -28,7 +28,7 @@ const typePurlsCache = {};
  *
  * @param {Object} options Command line options
  */
-export const prepareDB = async (options) => {
+export async function prepareDB(options) {
   if (!options.dbPath.includes("memory") && !fs.existsSync(options.dbPath)) {
     try {
       fs.mkdirSync(options.dbPath, { recursive: true });
@@ -93,14 +93,14 @@ export const prepareDB = async (options) => {
     await createAndStoreSlice(purl, purlsJars, Usages, options);
   }
   return { sequelize, Namespaces, Usages, DataFlows };
-};
+}
 
-export const catalogMavenDeps = async (
+export async function catalogMavenDeps(
   dirPath,
   purlsJars,
   Namespaces,
   options = {},
-) => {
+) {
   let jarNSMapping = undefined;
   if (fs.existsSync(path.join(dirPath, "bom.json.map"))) {
     try {
@@ -144,9 +144,9 @@ export const catalogMavenDeps = async (
       });
     }
   }
-};
+}
 
-export const catalogGradleDeps = async (dirPath, purlsJars, Namespaces) => {
+export async function catalogGradleDeps(dirPath, purlsJars, Namespaces) {
   console.log(
     "About to collect jar dependencies from the gradle cache. This would take a while ...",
   );
@@ -180,14 +180,14 @@ export const catalogGradleDeps = async (dirPath, purlsJars, Namespaces) => {
   console.log(
     "To speed up successive re-runs, pass the argument --skip-maven-collector to evinse command.",
   );
-};
+}
 
-export const createAndStoreSlice = async (
+export async function createAndStoreSlice(
   purl,
   purlsJars,
   Usages,
   options = {},
-) => {
+) {
   const retMap = createSlice(purl, purlsJars[purl], "usages", options);
   let sliceData = undefined;
   if (retMap?.slicesFile && fs.existsSync(retMap.slicesFile)) {
@@ -203,14 +203,14 @@ export const createAndStoreSlice = async (
     fs.rmSync(retMap.tempDir, { recursive: true, force: true });
   }
   return sliceData;
-};
+}
 
-export const createSlice = (
+export async function createSlice(
   purlOrLanguages,
   filePath,
   sliceType = "usages",
   options = {},
-) => {
+) {
   if (!filePath) {
     return;
   }
@@ -290,9 +290,9 @@ export const createSlice = (
     slicesFile,
     atomFile,
   };
-};
+}
 
-export const purlToLanguage = (purl, filePath) => {
+export function purlToLanguage(purl, filePath) {
   let language = undefined;
   const purlObj = PackageURL.fromString(purl);
   switch (purlObj.type) {
@@ -312,9 +312,9 @@ export const purlToLanguage = (purl, filePath) => {
       language = "c";
   }
   return language;
-};
+}
 
-export const initFromSbom = (components, language) => {
+export function initFromSbom(components, language) {
   const purlLocationMap = {};
   const purlImportsMap = {};
   for (const comp of components) {
@@ -344,7 +344,7 @@ export const initFromSbom = (components, language) => {
     purlLocationMap,
     purlImportsMap,
   };
-};
+}
 
 /**
  * Function to analyze the project
@@ -352,7 +352,7 @@ export const initFromSbom = (components, language) => {
  * @param {Object} dbObjMap DB and model instances
  * @param {Object} options Command line options
  */
-export const analyzeProject = async (dbObjMap, options) => {
+export async function analyzeProject(dbObjMap, options) {
   const dirPath = options._[0] || ".";
   const languages = options.language;
   const language = Array.isArray(languages) ? languages[0] : languages;
@@ -502,16 +502,16 @@ export const analyzeProject = async (dbObjMap, options) => {
     cryptoComponents,
     cryptoGeneratePurls,
   };
-};
+}
 
-export const parseObjectSlices = async (
+export async function parseObjectSlices(
   language,
   usageSlice,
   dbObjMap,
   servicesMap = {},
   purlLocationMap = {},
   purlImportsMap = {},
-) => {
+) {
   if (!usageSlice || !Object.keys(usageSlice).length) {
     return purlLocationMap;
   }
@@ -548,7 +548,7 @@ export const parseObjectSlices = async (
     servicesMap,
     userDefinedTypesMap,
   };
-};
+}
 
 /**
  * The implementation of this function is based on the logic proposed in the atom slices specification
@@ -562,14 +562,14 @@ export const parseObjectSlices = async (
  * @param {Object} purlImportsMap Object to track package urls and their import aliases
  * @returns
  */
-export const parseSliceUsages = async (
+export async function parseSliceUsages(
   language,
   userDefinedTypesMap,
   slice,
   dbObjMap,
   purlLocationMap,
   purlImportsMap,
-) => {
+) {
   const fileName = slice.fileName;
   const typesToLookup = new Set();
   const lKeyOverrides = {};
@@ -764,7 +764,7 @@ export const parseSliceUsages = async (
       }
     }
   }
-};
+}
 
 /**
  * Method to parse semantic slice data
@@ -887,11 +887,7 @@ function searchSymbolLocations(compSymbols, fileIndexes) {
   return searchHits;
 }
 
-export const isFilterableType = (
-  language,
-  userDefinedTypesMap,
-  typeFullName,
-) => {
+export function isFilterableType(language, userDefinedTypesMap, typeFullName) {
   if (
     !typeFullName ||
     ["ANY", "UNKNOWN", "VOID", "IMPORT"].includes(typeFullName.toUpperCase())
@@ -956,7 +952,7 @@ export const isFilterableType = (
     return true;
   }
   return false;
-};
+}
 
 /**
  * Method to detect services from annotation objects in the usage slice
@@ -965,7 +961,7 @@ export const isFilterableType = (
  * @param {Array} slice Usages array for each objectSlice
  * @param {Object} servicesMap Existing service map
  */
-export const detectServicesFromUsages = (language, slice, servicesMap = {}) => {
+export function detectServicesFromUsages(language, slice, servicesMap = {}) {
   const usages = slice.usages;
   if (!usages) {
     return [];
@@ -1022,7 +1018,7 @@ export const detectServicesFromUsages = (language, slice, servicesMap = {}) => {
       }
     }
   }
-};
+}
 
 /**
  * Method to detect services from user defined types in the usage slice
@@ -1031,11 +1027,7 @@ export const detectServicesFromUsages = (language, slice, servicesMap = {}) => {
  * @param {Array} userDefinedTypes User defined types
  * @param {Object} servicesMap Existing service map
  */
-export const detectServicesFromUDT = (
-  language,
-  userDefinedTypes,
-  servicesMap,
-) => {
+export function detectServicesFromUDT(language, userDefinedTypes, servicesMap) {
   if (
     ["python", "py", "c", "cpp", "c++", "php"].includes(language) &&
     userDefinedTypes &&
@@ -1089,9 +1081,9 @@ export const detectServicesFromUDT = (
       }
     }
   }
-};
+}
 
-export const constructServiceName = (_language, slice) => {
+export function constructServiceName(_language, slice) {
   let serviceName = "service";
   if (slice?.fullName) {
     serviceName = slice.fullName.split(":")[0].replace(/\./g, "-");
@@ -1102,9 +1094,9 @@ export const constructServiceName = (_language, slice) => {
     serviceName = `${serviceName}-service`;
   }
   return serviceName;
-};
+}
 
-export const extractEndpoints = (language, code) => {
+export function extractEndpoints(language, code) {
   if (!code) {
     return undefined;
   }
@@ -1155,7 +1147,7 @@ export const extractEndpoints = (language, code) => {
       break;
   }
   return endpoints;
-};
+}
 
 /**
  * Method to create the SBOM with evidence file called evinse file.
@@ -1164,7 +1156,7 @@ export const extractEndpoints = (language, code) => {
  * @param {Object} options Command line options
  * @returns
  */
-export const createEvinseFile = (sliceArtefacts, options) => {
+export function createEvinseFile(sliceArtefacts, options) {
   const {
     tempDir,
     usagesSlicesFile,
@@ -1311,7 +1303,7 @@ export const createEvinseFile = (sliceArtefacts, options) => {
   }
   // Redo post processing with evinse data
   return bomNSData?.bomJson;
-};
+}
 
 /**
  * Method to convert dataflow slice into usable callstack frames
@@ -1324,14 +1316,14 @@ export const createEvinseFile = (sliceArtefacts, options) => {
  * @param {Object} _purlLocationMap Object to track locations where purls are used
  * @param {Object} purlImportsMap Object to track package urls and their import aliases
  */
-export const collectDataFlowFrames = async (
+export async function collectDataFlowFrames(
   language,
   userDefinedTypesMap,
   dataFlowSlice,
   dbObjMap,
   _purlLocationMap,
   purlImportsMap,
-) => {
+) {
   const nodes = dataFlowSlice?.graph?.nodes || [];
   // Cache the nodes based on the id to improve lookup
   const nodeCache = {};
@@ -1438,7 +1430,7 @@ export const collectDataFlowFrames = async (
     }
   }
   return dfFrames;
-};
+}
 
 /**
  * Method to convert reachable slice into usable callstack frames and crypto components
@@ -1448,7 +1440,7 @@ export const collectDataFlowFrames = async (
  * @param {string} _language Application language
  * @param {Object} reachablesSlice Reachables slice object from atom
  */
-export const collectReachableFrames = (_language, reachablesSlice) => {
+export function collectReachableFrames(_language, reachablesSlice) {
   const reachableNodes = reachablesSlice?.reachables || [];
   // purl key and an array of frames array
   // CycloneDX 1.5 currently accepts only 1 frame as evidence
@@ -1536,7 +1528,7 @@ export const collectReachableFrames = (_language, reachablesSlice) => {
     cryptoComponents,
     cryptoGeneratePurls,
   };
-};
+}
 
 /**
  * Method to pick a callstack frame as an evidence. This method is required since CycloneDX 1.5 accepts only a single frame as evidence.
@@ -1544,7 +1536,7 @@ export const collectReachableFrames = (_language, reachablesSlice) => {
  * @param {Array} dfFrames Data flow frames
  * @returns
  */
-export const framePicker = (dfFrames) => {
+export function framePicker(dfFrames) {
   if (!dfFrames || !dfFrames.length) {
     return undefined;
   }
@@ -1557,7 +1549,7 @@ export const framePicker = (dfFrames) => {
     }
   }
   return aframe;
-};
+}
 
 /**
  * Method to simplify types. For example, arrays ending with [] could be simplified.
@@ -1565,11 +1557,11 @@ export const framePicker = (dfFrames) => {
  * @param {string} typeFullName Full name of the type to simplify
  * @returns Simplified type string
  */
-export const simplifyType = (typeFullName) => {
+export function simplifyType(typeFullName) {
   return typeFullName.replace("[]", "");
-};
+}
 
-export const getClassTypeFromSignature = (language, typeFullName) => {
+export function getClassTypeFromSignature(language, typeFullName) {
   if (["java", "jar"].includes(language) && typeFullName.includes(":")) {
     typeFullName = typeFullName.split(":")[0];
     const tmpA = typeFullName.split(".");
@@ -1610,11 +1602,11 @@ export const getClassTypeFromSignature = (language, typeFullName) => {
     typeFullName = typeFullName.split("$")[0];
   }
   return simplifyType(typeFullName);
-};
+}
 
-const addToOverrides = (lKeyOverrides, atype, fileName, ausageLineNumber) => {
+function addToOverrides(lKeyOverrides, atype, fileName, ausageLineNumber) {
   if (!lKeyOverrides[atype]) {
     lKeyOverrides[atype] = new Set();
   }
   lKeyOverrides[atype].add(`${fileName}#${ausageLineNumber}`);
-};
+}

package/lib/helpers/display.js

@@ -293,7 +293,7 @@ export function printDependencyTree(
     // https://github.com/nodejs/node/issues/35973
     console.log(highlightStr(treeGraphics.join("\n"), highlight));
   } else {
-    console.log("Dependency tree is too large to print.");
+    console.log(highlightStr(treeGraphics.slice(0, 500).join("\n"), highlight));
   }
 }
 

package/lib/helpers/utils.js

@@ -26,6 +26,7 @@ import path, {
 } from "node:path";
 import process from "node:process";
 import { URL, fileURLToPath } from "node:url";
+import toml from "@iarna/toml";
 import Arborist from "@npmcli/arborist";
 import { load } from "cheerio";
 import { parseEDNString } from "edn-data";
@@ -45,7 +46,6 @@ import {
   satisfies,
   valid,
 } from "semver";
-import toml from "toml";
 import { IriValidationStrategy, validateIri } from "validate-iri";
 import { xml2js } from "xml-js";
 import { getTreeWithPlugin } from "../managers/piptree.js";
@@ -538,7 +538,6 @@ export function getAllFiles(dirPath, pattern, options = {}) {
     "**/.hg/**",
     "**/.git/**",
     "**/venv/**",
-    "**/docs/**",
     "**/examples/**",
     "**/site-packages/**",
     "**/flow-typed/**",
@@ -548,6 +547,15 @@ export function getAllFiles(dirPath, pattern, options = {}) {
   if (!pattern.includes("package.json")) {
     ignoreList.push("**/node_modules/**");
   }
+  // ignore docs only for non-lock file lookups
+  if (
+    !pattern.includes("package.json") &&
+    !pattern.includes("package-lock.json") &&
+    !pattern.includes("yarn.lock") &&
+    !pattern.includes("pnpm-lock.yaml")
+  ) {
+    ignoreList.push("**/docs/**");
+  }
   if (options?.exclude && Array.isArray(options.exclude)) {
     ignoreList = ignoreList.concat(options.exclude);
   }
@@ -3183,8 +3191,6 @@ export function executeParallelGradleProperties(dir, allProjectsStr) {
       ? process.env.GRADLE_ARGS_PROPERTIES.split(" ")
       : [],
   );
-
-  console.log("Executing", gradleCmd, gradleArgs.join(" "), "in", dir);
   const result = spawnSync(gradleCmd, gradleArgs, {
     cwd: dir,
     encoding: "utf-8",
@@ -4081,7 +4087,14 @@ export async function parsePoetrylockData(lockData, lockFile, pyProjectFile) {
     pyProjectFile = lockFile.replace("poetry.lock", "pyproject.toml");
     if (existsSync(pyProjectFile)) {
       const pyprojTomlFile = readFileSync(pyProjectFile, { encoding: "utf-8" });
-      const tomlData = toml.parse(pyprojTomlFile);
+      let tomlData;
+      try {
+        tomlData = toml.parse(pyprojTomlFile);
+      } catch (err) {
+        console.log(
+          `Error while parsing the file ${pyprojTomlFile}. Dependency tree information might be incorrect.`,
+        );
+      }
       if (tomlData?.tool?.poetry) {
         for (const adep of Object.keys(tomlData?.tool?.poetry?.dependencies)) {
           if (
@@ -6003,57 +6016,46 @@ export async function getCratesMetadata(pkgList) {
  * @param {Array} pkgList Package list
  */
 export async function getDartMetadata(pkgList) {
-  const RESPONSE_TYPE = "json";
-  const HEADER_ACCEPT = "application/vnd.pub.v2+json";
   const PUB_DEV_URL = process.env.PUB_DEV_URL || "https://pub.dev";
-  const PUB_PACKAGES_URL = `${PUB_DEV_URL}/api/packages/`;
   const PUB_LICENSE_REGEX = /^license:/i;
-  const cdepList = [];
+  const OPTIONS = {
+    responseType: "json",
+    headers: {
+      Accept: "application/vnd.pub.v2+json",
+    },
+  };
 
+  const cdepList = [];
   for (const p of pkgList) {
     try {
       if (DEBUG_MODE) {
         console.log(`Querying ${PUB_DEV_URL} for ${p.name}`);
       }
-      const res = await cdxgenAgent.get(PUB_PACKAGES_URL + p.name, {
-        responseType: RESPONSE_TYPE,
-        headers: {
-          Accept: HEADER_ACCEPT,
-        },
-      });
+      const PUB_PACKAGE_URL = `${PUB_DEV_URL}/api/packages/${p.name}/versions/${p.version}`;
+      const PUB_PACKAGE_SCORE_URL = `${PUB_PACKAGE_URL}/score`;
+      const res = await cdxgenAgent.get(PUB_PACKAGE_URL, OPTIONS);
       if (res?.body) {
-        const version = res.body.versions.find((v) => p.version === v.version);
-        if (version) {
-          const pubspec = version.pubspec;
-          p.description = pubspec.description;
-          if (pubspec.repository) {
-            p.repository = { url: pubspec.repository };
-          }
-          if (pubspec.homepage) {
-            p.homepage = { url: pubspec.homepage };
-          }
-          const res2 = await cdxgenAgent.get(
-            `${PUB_PACKAGES_URL + p.name}/score`,
-            {
-              responseType: RESPONSE_TYPE,
-              headers: {
-                Accept: HEADER_ACCEPT,
-              },
-            },
-          );
-          if (res2?.body) {
-            const tags = res2.body.tags;
-            const license = tags.find((tag) => PUB_LICENSE_REGEX.test(tag));
-            if (license) {
-              p.license = spdxLicenses.find(
-                (spdxLicense) =>
-                  spdxLicense.toLowerCase() ===
-                  license.replace(PUB_LICENSE_REGEX, "").toLowerCase(),
-              );
-            }
+        const pubspec = res.body.pubspec;
+        p.description = pubspec.description;
+        if (pubspec.repository) {
+          p.repository = { url: pubspec.repository };
+        }
+        if (pubspec.homepage) {
+          p.homepage = { url: pubspec.homepage };
+        }
+        const score = await cdxgenAgent.get(PUB_PACKAGE_SCORE_URL, OPTIONS);
+        if (score?.body) {
+          const tags = score.body.tags;
+          const license = tags.find((tag) => PUB_LICENSE_REGEX.test(tag));
+          if (license) {
+            p.license = spdxLicenses.find(
+              (spdxLicense) =>
+                spdxLicense.toLowerCase() ===
+                license.replace(PUB_LICENSE_REGEX, "").toLowerCase(),
+            );
           }
-          cdepList.push(p);
         }
+        cdepList.push(p);
       }
     } catch (err) {
       cdepList.push(p);
@@ -8572,6 +8574,50 @@ export function parsePaketLockData(paketLockData, pkgLockFile) {
   };
 }
 
+/**
+ * Parse composer.json file
+ *
+ * @param {string} composerJsonFile composer.json file
+ *
+ * @returns {Object} Object with rootRequires and parent component
+ */
+export function parseComposerJson(composerJsonFile) {
+  const moduleParent = {};
+  const composerData = JSON.parse(
+    readFileSync(composerJsonFile, { encoding: "utf-8" }),
+  );
+  const rootRequires = composerData.require;
+  const pkgName = composerData.name;
+  if (pkgName) {
+    moduleParent.group = dirname(pkgName);
+    if (moduleParent.group === ".") {
+      moduleParent.group = "";
+    }
+    moduleParent.name = basename(pkgName);
+    moduleParent.type = "application";
+    moduleParent.version = composerData.version;
+    if (composerData.description) {
+      moduleParent.description = composerData.description;
+    }
+    if (composerData.license) {
+      moduleParent.licenses = getLicenses({
+        expression: composerData.license,
+      });
+    }
+    moduleParent["bom-ref"] = decodeURIComponent(
+      new PackageURL(
+        "composer",
+        moduleParent.group,
+        moduleParent.name,
+        moduleParent.version,
+        null,
+        null,
+      ).toString(),
+    );
+  }
+  return { rootRequires, moduleParent };
+}
+
 /**
  * Parse composer lock file
  *
@@ -8658,6 +8704,17 @@ export function parseComposerLock(pkgLockFile, rootRequires) {
               },
             },
           };
+          if (pkg?.dist?.url) {
+            apkg.distribution = { url: pkg.dist.url };
+          }
+          if (pkg?.authors?.length) {
+            apkg.authors = pkg.authors.map((a) => {
+              return { name: a.name, email: a.email };
+            });
+          }
+          if (pkg?.keywords?.length) {
+            apkg.tags = pkg.keywords;
+          }
           if (pkg.autoload && Object.keys(pkg.autoload).length) {
             const namespaces = [];
             for (const aaload of Object.keys(pkg.autoload)) {
@@ -10807,11 +10864,6 @@ export function getPipFrozenTree(
             "Install suitable version of python or set the environment variable PYTHON_CMD.",
           );
         }
-        if (!result.stderr) {
-          console.log(
-            "Ensure the virtualenv package is installed using pip. `python -m pip install virtualenv`",
-          );
-        }
       }
     } else {
       if (DEBUG_MODE) {
@@ -11678,7 +11730,8 @@ export function parseCmakeLikeFile(cmakeListFile, pkgType, options = {}) {
           .split(")")[0]
           .split(",")
           .filter((v) => v.length > 1);
-        const parentName = tmpB[0].replace(":", "");
+        const parentName =
+          tmpB.length > 0 ? tmpB[0].replace(":", "").trim() : "";
         let parentVersion = undefined;
         // In case of meson.build we can find the version number after the word version
         // thanks to our replaces and splits

package/lib/helpers/utils.test.js

@@ -3720,7 +3720,17 @@ test("parseComposerLock", () => {
     group: "quickbooks",
     name: "v3-php-sdk",
     scope: "required",
+    tags: ["api", "http", "quickbooks", "rest", "smallbusiness"],
     version: "v4.0.6.1",
+    authors: [
+      {
+        email: "Hao_Lu@intuit.com",
+        name: "hlu2",
+      },
+    ],
+    distribution: {
+      url: "https://api.github.com/repos/intuit/QuickBooks-V3-PHP-SDK/zipball/fe42e409bcdc431614f1cfc80cfc4191b926f3ed",
+    },
     purl: "pkg:composer/quickbooks/v3-php-sdk@v4.0.6.1",
     "bom-ref": "pkg:composer/quickbooks/v3-php-sdk@v4.0.6.1",
     repository: {
@@ -3765,13 +3775,45 @@ test("parseComposerLock", () => {
     version: "v2.4.4",
     purl: "pkg:composer/amphp/amp@v2.4.4",
     "bom-ref": "pkg:composer/amphp/amp@v2.4.4",
+    authors: [
+      {
+        email: "rdlowrey@php.net",
+        name: "Daniel Lowrey",
+      },
+      {
+        email: "aaron@trowski.com",
+        name: "Aaron Piotrowski",
+      },
+      {
+        email: "bobwei9@hotmail.com",
+        name: "Bob Weinand",
+      },
+      {
+        email: "me@kelunik.com",
+        name: "Niklas Keller",
+      },
+    ],
     repository: {
       type: "git",
       url: "https://github.com/amphp/amp.git",
       reference: "1e58d53e4af390efc7813e36cd215bd82cba4b06",
     },
+    distribution: {
+      url: "https://api.github.com/repos/amphp/amp/zipball/1e58d53e4af390efc7813e36cd215bd82cba4b06",
+    },
     license: ["MIT"],
     description: "A non-blocking concurrency framework for PHP applications.",
+    tags: [
+      "async",
+      "asynchronous",
+      "awaitable",
+      "concurrency",
+      "event",
+      "event-loop",
+      "future",
+      "non-blocking",
+      "promise",
+    ],
     properties: [
       {
         name: "SrcFile",
@@ -3806,6 +3848,24 @@ test("parseComposerLock", () => {
     version: "v2.6.2",
     purl: "pkg:composer/amphp/amp@v2.6.2",
     "bom-ref": "pkg:composer/amphp/amp@v2.6.2",
+    authors: [
+      {
+        email: "rdlowrey@php.net",
+        name: "Daniel Lowrey",
+      },
+      {
+        email: "aaron@trowski.com",
+        name: "Aaron Piotrowski",
+      },
+      {
+        email: "bobwei9@hotmail.com",
+        name: "Bob Weinand",
+      },
+      {
+        email: "me@kelunik.com",
+        name: "Niklas Keller",
+      },
+    ],
     repository: {
       type: "git",
       url: "https://github.com/amphp/amp.git",
@@ -3813,6 +3873,20 @@ test("parseComposerLock", () => {
     },
     license: ["MIT"],
     description: "A non-blocking concurrency framework for PHP applications.",
+    distribution: {
+      url: "https://api.github.com/repos/amphp/amp/zipball/9d5100cebffa729aaffecd3ad25dc5aeea4f13bb",
+    },
+    tags: [
+      "async",
+      "asynchronous",
+      "awaitable",
+      "concurrency",
+      "event",
+      "event-loop",
+      "future",
+      "non-blocking",
+      "promise",
+    ],
     scope: "required",
     properties: [
       { name: "SrcFile", value: "./test/data/composer-3.lock" },
@@ -3852,6 +3926,7 @@ test("parseComposerLock", () => {
     license: ["Apache-2.0"],
     description: "A versatile logging framework for PHP",
     scope: "required",
+    tags: ["log", "logging", "php"],
     properties: [{ name: "SrcFile", value: "./test/data/composer-4.lock" }],
     evidence: {
       identity: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cyclonedx/cdxgen",
-  "version": "11.0.2",
+  "version": "11.0.4",
   "description": "Creates CycloneDX Software Bill of Materials (SBOM) from source or container image",
   "homepage": "http://github.com/cyclonedx/cdxgen",
   "author": "Prabhu Subramanian <prabhu@appthreat.com>",
@@ -71,7 +71,7 @@
     "find-up": "7.0.0",
     "glob": "^11.0.0",
     "global-agent": "^3.0.0",
-    "got": "^14.4.4",
+    "got": "^14.4.5",
     "iconv-lite": "^0.6.3",
     "js-yaml": "^4.1.0",
     "jws": "^4.0.0",
@@ -83,11 +83,11 @@
     "ssri": "^12.0.0",
     "table": "^6.8.2",
     "tar": "^7.4.3",
-    "toml": "^3.0.0",
     "uuid": "^11.0.2",
     "validate-iri": "^1.0.1",
     "xml-js": "^1.6.11",
-    "yargs": "^17.7.2"
+    "yargs": "^17.7.2",
+    "@iarna/toml": "2.2.5"
   },
   "optionalDependencies": {
     "@appthreat/atom": "2.0.25",
@@ -103,7 +103,7 @@
     "body-parser": "^2.0.1",
     "compression": "^1.7.5",
     "connect": "^3.7.0",
-    "jsonata": "^2.0.5",
+    "jsonata": "^2.0.6",
     "sequelize": "^6.37.4",
     "sqlite3": "^5.1.7"
   },
@@ -117,7 +117,7 @@
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
     "jest": "^29.7.0",
-    "typescript": "^5.6.2"
+    "typescript": "^5.7.2"
   },
   "overrides": {
     "glob": "^11.0.0",

package/types/jest.config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jest.config.d.ts","sourceRoot":"","sources":["../jest.config.js"],"names":[],"mappings":"AAAA,8BAA+B;AAC/B,2CAA4C;AAC5C,kDAA0E;AAC1E,yCAAkD;AAClD,qCAAsC"}
+{"version":3,"file":"jest.config.d.ts","sourceRoot":"","sources":["../jest.config.js"],"names":[],"mappings":"AAAA,yBAA0B,IAAI,CAAC;AAC/B,gCAAiC,UAAU,CAAC;AAC5C,kDAA0E;AAC1E,yCAAkD;AAClD,8BAA+B,MAAM,CAAC"}

package/types/lib/cli/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/cli/index.js"],"names":[],"mappings":"AA0wBA;;;;;;;;GAQG;AACH,gFAFW,MAAM,SAchB;AAyUD;;;;;;;GAOG;AACH,mCALW,MAAM,qBAiEhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM;;;;EAKhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM;;;;EAkBhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAs5BhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,8BAsehB;AAED;;;;;;;;;;GAUG;AACH,+DAsEC;AAED;;;;;GAKG;AACH,sCAHW,MAAM,8BA6bhB;AAED;;;;;GAKG;AACH,kCAHW,MAAM,8BA+YhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAqIhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAiDhB;AAED;;;;;GAKG;AACH,mCAHW,MAAM,qBA+KhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM,qBAsHhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,0CAHW,MAAM,qBAuBhB;AAED;;;;;GAKG;AACH,mCAHW,MAAM,8BAqDhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM,8BA4ChB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,qCAHW,MAAM,8BA6FhB;AAED;;;;;GAKG;AACH,iDAHW,MAAM,qBAiUhB;AAED;;;;;GAKG;AACH,mCAHW,MAAM,qBAqJhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAmFhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,8BA4XhB;AAED;;;;;GAKG;AACH,2CAHW,MAAM;;;;;;;;;;;;;;;;;;;;GAoChB;AAED;;;;;;;;KA+DC;AAED;;;;;;GAMG;AACH,yDAuCC;AAED;;;;;;;;;GASG;AACH,2GA6BC;AAED;;;;;GAKG;AACH,0CAHW,MAAM,EAAE,8BAmclB;AAED;;;;;GAKG;AACH,iCAHW,MAAM,8BAiUhB;AAED;;;;;GAKG;AACH,gCAHW,MAAM,qBAqOhB;AAED;;;;;;GAMG;AACH,wDAFY,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,SAAS,CAAC,CAwHxE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/cli/index.js"],"names":[],"mappings":"AA4wBA;;;;;;;;GAQG;AACH,gFAFW,MAAM,SAchB;AAyVD;;;;;;;GAOG;AACH,mCALW,MAAM,qBAiEhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM;;;;EAKhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM;;;;EAkBhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAs5BhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,8BA2ehB;AAED;;;;;;;;;;GAUG;AACH,+DAsEC;AAED;;;;;GAKG;AACH,sCAHW,MAAM,8BA6bhB;AAED;;;;;GAKG;AACH,kCAHW,MAAM,8BA+YhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAqIhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAiDhB;AAED;;;;;GAKG;AACH,mCAHW,MAAM,qBA+KhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM,qBAsHhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,0CAHW,MAAM,qBAuBhB;AAED;;;;;GAKG;AACH,mCAHW,MAAM,8BAqDhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM,8BA4ChB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,qCAHW,MAAM,8BA6FhB;AAED;;;;;GAKG;AACH,iDAHW,MAAM,qBAiUhB;AAED;;;;;GAKG;AACH,mCAHW,MAAM,qBAqJhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAmFhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,8BA4XhB;AAED;;;;;GAKG;AACH,2CAHW,MAAM;;;;;;;;;;;;;;;;;;;;GAoChB;AAED;;;;;;;;KA+DC;AAED;;;;;;GAMG;AACH,yDAuCC;AAED;;;;;;;;;GASG;AACH,2GA6BC;AAED;;;;;GAKG;AACH,0CAHW,MAAM,EAAE,8BAmclB;AAED;;;;;GAKG;AACH,iCAHW,MAAM,8BAgUhB;AAED;;;;;GAKG;AACH,gCAHW,MAAM,qBAqOhB;AAED;;;;;;GAMG;AACH,wDAFY,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,SAAS,CAAC,CAwHxE"}

package/types/lib/helpers/utils.d.ts

@@ -716,6 +716,14 @@ export function parsePaketLockData(paketLockData: any, pkgLockFile: any): {
     pkgList: any[];
     dependenciesList: any[];
 };
+/**
+ * Parse composer.json file
+ *
+ * @param {string} composerJsonFile composer.json file
+ *
+ * @returns {Object} Object with rootRequires and parent component
+ */
+export function parseComposerJson(composerJsonFile: string): any;
 /**
  * Parse composer lock file
  *

package/types/lib/helpers/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../lib/helpers/utils.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../lib/helpers/utils.js"],"names":[],"mappings":"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"}

package/types/lib/managers/docker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"docker.d.ts","sourceRoot":"","sources":["../../../lib/managers/docker.js"],"names":[],"mappings":"AAoDA;;GAEG;AACH,4CA6CC;AAxED,4BAA6C;AAC7C,8CAA+C;AAkFxC,iCAHI,MAAM,WACN,MAAM,iDAehB;AAqBM,6DAmBN;AAgLM,4EAsGN;AAEM,oFAwBN;AAUM;;;;;;;;EAwEN;AAsBM,2DA6KN;AAEM,2EA4FN;AAMM;;;;;;;;;;;;;GAqDN;AAEM;;;;;;;GAqGN;AAMM,8DAqIN;AAKM,4EAmGN;AAEM,+EAMN;AAEM,4EAyCN;AAEM,iFA0BN"}
+{"version":3,"file":"docker.d.ts","sourceRoot":"","sources":["../../../lib/managers/docker.js"],"names":[],"mappings":"AAoDA;;GAEG;AACH,4CA6CC;AAxED,4BAA6C;AAC7C,kCAAmC,WAAW,CAAC;AAkFxC,iCAHI,MAAM,WACN,MAAM,iDAehB;AAqBM,6DAmBN;AAgLM,4EAsGN;AAEM,oFAwBN;AAUM;;;;;;;;EAwEN;AAsBM,2DA6KN;AAEM,2EA4FN;AAMM;;;;;;;;;;;;;GAqDN;AAEM;;;;;;;GAqGN;AAMM,8DAqIN;AAKM,4EAmGN;AAEM,+EAMN;AAEM,4EAyCN;AAEM,iFA0BN"}