@cdxgen/cdxgen 13.1.0 → 13.3.0

package/types/lib/ecosystems/rubyutils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rubyutils.d.ts","sourceRoot":"","sources":["../../../lib/ecosystems/rubyutils.js"],"names":[],"mappings":"AA2DA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAHzB,MAGyB,GAFvB,OAAO,CAOnB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAHlC,MAAM,GAAG,SAGyB,GAFhC,MAAM,GAAG,SAAS,CAO9B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAHrC,MAAM,GAAG,SAG4B,GAFnC;IAAC,OAAO,EAAE,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAAC,QAAQ,EAAE,CAAC,MAAM,GAAG,SAAS,CAAC,CAAA;CAAC,CAe3E;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAHhC,MAGgC,GAF9B,MAAM,CAIlB;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,IAAI,EALnB,MAKmB,EAAE,OAAO,EAJ5B,MAAM,GAAG,SAImB,EAAE,QAAQ,EAHtC,MAAM,GAAG,SAG6B,GAFpC,MAAM,CAclB;AAsED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAH9B,MAG8B,GAF5B;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;CAAC,GAAG,SAAS,CAqBjE;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,IAF1B,MAAM,CAWlB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAHnC,MAGmC,GAFjC,MAAM,CAiClB;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAHjC,MAGiC,GAF/B,MAAM,CAgClB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,wBAAwB,CAAC,OAAO,OAAA,EAAE,OAAO,GAJ5D;IAAwB,OAAO,EAAvB,MAAM,CACd;IAAwB,oBAAoB,EAApC,MAAM,CACd;CAEiE,GAFvD,OAAO,OAAO,CA+I1B;AAwID;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,OAAA,kBAmIhD;AA8CD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,KAAA,YAsBpC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CACnC,WAAW,QAAA,EACX,aAAa,QAAA,EACb,OAAO,QAAA,EACP,OAAO,QAAA,EACP,QAAQ,QAAA,GAPG,KAAK,CAAC,MAAM,CAAC,CA4IzB;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,WAAW,EAHvC,MAGuC,EAAE,WAAW,EAFpD,MAEoD,kBAwQ9D;AAED;;;;;GAKG;AACH,wBAAsB,oBAAoB,CAAC,WAAW,EAH3C,MAG2C,EAAE,QAAQ,EAFrD,MAEqD;;;;;;;GAgV/D"}
+{"version":3,"file":"rubyutils.d.ts","sourceRoot":"","sources":["../../../lib/ecosystems/rubyutils.js"],"names":[],"mappings":"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"}

package/types/lib/ecosystems/rusi.d.ts

@@ -1,3 +1,16 @@
+/**
+ * Returns the backend rusi actually used. `options.backend` is only the
+ * requested backend: when the compiler backend cannot run (missing
+ * components, wrapper build failure), rusi still echoes "compiler" but falls
+ * back to the stable source analysis. Compiler evidence was collected only
+ * when rusi emits its compiler-source-evidence diagnostic; a backend-error
+ * alone is not conclusive because native interop scanning reports failures
+ * under that kind too.
+ *
+ * @param {Object} rusiReport Parsed rusi report
+ * @returns {string|undefined} Effective backend name
+ */
+export declare function effectiveRusiBackend(rusiReport?: Object): string | undefined;
 /**
  * Checks if the provided language is a Rust language alias.
  *

package/types/lib/ecosystems/rusi.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rusi.d.ts","sourceRoot":"","sources":["../../../lib/ecosystems/rusi.js"],"names":[],"mappings":"AAsnBA;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAHhC,MAGgC,GAF9B,OAAO,CAInB;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAH9B,MAG8B,GAF5B,MAAM,GAAC,SAAS,CAW5B;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,GAAG,EALxB,MAKwB,EAAE,UAAU,EAJpC,MAIoC,EAAE,OAAO,GAH7C,MAGkD,GAFhD,OAAO,CAuDnB;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAJ3B,MAI2B,EAAE,OAAO,GAHpC,MAGyC,GAFvC,MAAM,GAAC,SAAS,CA2B5B;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,GAJnC,MAIwC,EAAE,UAAU,QAAK,GAFvD,MAAM,CA4DlB"}
+{"version":3,"file":"rusi.d.ts","sourceRoot":"","sources":["../../../lib/ecosystems/rusi.js"],"names":[],"mappings":"AAgWA;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,GAHpC,MAGyC,GAFvC,MAAM,GAAC,SAAS,CAW5B;AAsZD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAHhC,MAGgC,GAF9B,OAAO,CAInB;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAH9B,MAG8B,GAF5B,MAAM,GAAC,SAAS,CAW5B;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,GAAG,EALxB,MAKwB,EAAE,UAAU,EAJpC,MAIoC,EAAE,OAAO,GAH7C,MAGkD,GAFhD,OAAO,CAuDnB;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAJ3B,MAI2B,EAAE,OAAO,GAHpC,MAGyC,GAFvC,MAAM,GAAC,SAAS,CA2B5B;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,GAJnC,MAIwC,EAAE,UAAU,QAAK,GAFvD,MAAM,CA8DlB"}

package/types/lib/evinser/evinser.d.ts

@@ -1,3 +1,30 @@
+/**
+ * Merges one analyzer run's metadata properties into the BOM's metadata
+ * component. Analyzer metadata describes a single run, so when the input BOM
+ * already carries facts from an earlier run (cdxgen --profile research, then
+ * evinse), everything under the analyzer's own `cdx:<analyzer>:` prefix is
+ * replaced. Replacing by exact name would keep facts the new run no longer
+ * emits, such as a cdx:rusi:requestedBackend left from a fallback run.
+ *
+ * @param {Object} component Metadata component to update in place
+ * @param {Object[]} metadataProperties Properties from the analyzer run
+ */
+export declare function mergeAnalyzerMetadataProperties(component: Object, metadataProperties?: Object[]): void;
+/**
+ * Build the options for the evinse phase (prepareDB, analyzeProject, and
+ * createEvinseFile) from the cdxgen CLI options.
+ *
+ * This object used to be assembled inline in bin/cdxgen.js, which dropped
+ * fields the analyzers read - most notably `exclude`, so every dosai and atom
+ * run triggered by `--evidence` ignored the user's `--exclude` patterns. Keep
+ * the wiring in one place so the forwarded fields stay testable.
+ *
+ * @param {Object} options CLI options
+ * @param {Object} args Parsed CLI arguments; `args._[0]` is the source directory
+ * @param {string} input Path of the BOM file the evinse phase enriches
+ * @returns {Object} Options for prepareDB, analyzeProject, and createEvinseFile
+ */
+export declare function buildEvinseOptions(options: Object, args: Object, input: string): Object;
 /**
  * Function to create the db for the libraries referred in the sbom.
  *
@@ -91,8 +118,9 @@ export declare function purlToLanguage(purl: string, filePath?: string): string
  * Seed purl-location and import maps from SBOM component evidence.
  *
  * Walks the supplied components reading `internal:ImportedModules` (or
- * `internal:Namespaces` for php/ruby) and `evidence.occurrences` properties
- * to construct lookup maps used during slice analysis.
+ * `internal:Namespaces` for php/ruby, plus the `internal:ImportedSymbols` the
+ * C/C++ collector records) and `evidence.occurrences` properties to construct
+ * lookup maps used during slice analysis.
  *
  * @param {Object[]} components CycloneDX components from the input SBOM
  * @param {string} language Application language used to select the import property name
@@ -102,6 +130,26 @@ export declare function initFromSbom(components: Object[], language: string): {
     purlLocationMap: Record<string, Set<any>>;
     purlImportsMap: Record<string, string[]>;
 };
+/**
+ * Load a semantics slices file for reuse when it belongs to this project.
+ *
+ * `--semantics-slices-file` defaults to `semantics.slices.json` in the working
+ * directory, which is shared by every project scanned from there and also
+ * receives the reports of other analyzers (dosai, rusi, golem). A file is
+ * only reused when its shape matches the language. Swift slices must also
+ * describe the same project directory and must not predate the input SBOM:
+ * `cdxgen --evidence` writes a fresh SBOM before evinse runs, so an older
+ * slice was made from an earlier state of the sources and is regenerated.
+ * Scala slices cannot be regenerated by evinse and are reused whenever their
+ * shape matches.
+ *
+ * @param {string} language Project language
+ * @param {string} slicesFile Candidate semantics slices file
+ * @param {string} bomFile Input SBOM
+ * @param {string} dirPath Project directory
+ * @returns {undefined|Object} Parsed slice when it can be reused
+ */
+export declare function loadReusableSemanticsSlice(language: string, slicesFile: string, bomFile: string, dirPath: string): undefined | Object;
 /**
  * Function to analyze the project
  *
@@ -115,6 +163,7 @@ export declare function analyzeProject(dbObjMap: Object, options: Object): Promi
     userDefinedTypesMap: {};
     componentPropertiesMap?: undefined;
     metadataProperties?: undefined;
+    workspaceComponent?: undefined;
     atomFile?: undefined;
     usagesSlicesFile?: undefined;
     dataFlowSlicesFile?: undefined;
@@ -135,6 +184,26 @@ export declare function analyzeProject(dbObjMap: Object, options: Object): Promi
     cryptoGeneratePurls: any;
     servicesMap: {};
     userDefinedTypesMap: {};
+    workspaceComponent?: undefined;
+    atomFile?: undefined;
+    usagesSlicesFile?: undefined;
+    dataFlowSlicesFile?: undefined;
+    reachablesSlicesFile?: undefined;
+    semanticsSlicesFile?: undefined;
+    tempDir?: undefined;
+    tempDirOwned?: undefined;
+    aiComponents?: undefined;
+    openapiSpecFile?: undefined;
+} | {
+    purlLocationMap: {};
+    dataFlowFrames: {};
+    componentPropertiesMap: {};
+    metadataProperties: any[];
+    cryptoComponents: any[];
+    cryptoGeneratePurls: {};
+    servicesMap: {};
+    userDefinedTypesMap: {};
+    workspaceComponent: Object | undefined;
     atomFile?: undefined;
     usagesSlicesFile?: undefined;
     dataFlowSlicesFile?: undefined;
@@ -147,6 +216,7 @@ export declare function analyzeProject(dbObjMap: Object, options: Object): Promi
 } | {
     componentPropertiesMap?: undefined;
     metadataProperties?: undefined;
+    workspaceComponent?: undefined;
     usagesSlicesFile: any;
     dataFlowSlicesFile: any;
     semanticsSlicesFile: any;
@@ -165,6 +235,7 @@ export declare function analyzeProject(dbObjMap: Object, options: Object): Promi
 } | {
     componentPropertiesMap?: undefined;
     metadataProperties?: undefined;
+    workspaceComponent?: undefined;
     atomFile: any;
     usagesSlicesFile: any;
     dataFlowSlicesFile: any;
@@ -215,6 +286,14 @@ export declare function parseSliceUsages(language: string, userDefinedTypesMap:
 /**
  * Method to parse semantic slice data. Currently supported for swift and scala languages.
  *
+ * Swift slices created by cdxgen record, for every indexed source file, the
+ * lines that reference each dependency module (`moduleReferences`); the module
+ * of a reference is the declaring module recovered from the compiler-resolved
+ * USR. Components are mapped to their package's modules through the
+ * `packages` slice, so every occurrence is backed by a resolved reference.
+ * Slices without `moduleReferences` (created by older cdxgen versions) fall
+ * back to matching symbol names.
+ *
  * @param {String} language Project language.
  * @param {Array} components Components from the input SBOM
  * @param {Object} semanticsSlice Semantic slice data

package/types/lib/evinser/evinser.d.ts.map

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

package/types/lib/evinser/swiftsem.d.ts

@@ -1,11 +1,66 @@
+/**
+ * Convert a SwiftPM target or package name into its module name.
+ *
+ * @param {String} name Target or package name
+ * @returns {String} Module name
+ */
+export declare function toModuleName(name: string): string;
+/**
+ * Decide whether a module belongs to tests or to an aggregate product and so
+ * must not contribute build symbols or semantic context.
+ *
+ * @param {String} moduleName Module name
+ * @returns {boolean} `true` when the module should be skipped
+ */
+export declare function isTestOrAggregateModule(moduleName: string): boolean;
+/**
+ * Parse the JSON printed by `swift -print-target-info`.
+ *
+ * `paths.runtimeResourcePath` is `<toolchain>/usr/lib/swift` for every
+ * toolchain layout (Xcode, `.xctoolchain` bundles, swiftly, Linux tarballs),
+ * so it names the toolchain that actually compiles the project.
+ *
+ * @param {Object} targetInfo Parsed `-print-target-info` output
+ * @returns {undefined|Object} `{ compilerVersion, triple, runtimeResourcePath, toolchainDir }`
+ */
+export declare function parseSwiftTargetInfo(targetInfo: Object): undefined | Object;
+/**
+ * Identify the toolchain that `swift` resolves to inside a project directory.
+ *
+ * The query runs in the project directory because toolchain managers such as
+ * swiftly select the toolchain per directory (`.swift-version`), so the
+ * compiler that builds a project can differ from the one on the PATH of the
+ * calling process.
+ *
+ * @param {String} basePath Project directory
+ * @returns {undefined|Object} Toolchain details, see parseSwiftTargetInfo
+ */
+export declare function resolveSwiftToolchain(basePath: string): undefined | Object;
+/**
+ * Environment overrides that make sourcekitten load the SourceKit of the
+ * toolchain that builds the project.
+ *
+ * Without guidance sourcekitten uses the toolchain of the selected Xcode (or
+ * the `swift` found on the PATH on Linux). SourceKit cannot load modules
+ * produced by a different compiler version, so every reference to a
+ * dependency then goes unresolved. On macOS sourcekitten honours
+ * `XCODE_DEFAULT_TOOLCHAIN_OVERRIDE` ahead of `xcrun`; on Linux it honours
+ * `LINUX_SOURCEKIT_LIB_PATH`. Explicitly configured values always win.
+ *
+ * @param {Object} toolchain Toolchain details from resolveSwiftToolchain
+ * @param {String} [platform] Platform name, defaults to process.platform
+ * @returns {undefined|Object} Environment overrides for sourcekitten
+ */
+export declare function sourcekittenEnvForToolchain(toolchain: Object, platform?: string): undefined | Object;
 /**
  * Retrieve the structure information of a .swift file in json format
  *
  * @param {String} filePath Path to .swift file
+ * @param {Object} [env] Environment overrides for sourcekitten
  *
  * @returns {undefined|Object} JSON representation of the swift file or undefined.
  */
-export declare function getStructure(filePath: string): undefined | Object;
+export declare function getStructure(filePath: string, env?: Object): undefined | Object;
 /**
  * Parse the data from the structure command
  *
@@ -13,35 +68,150 @@ export declare function getStructure(filePath: string): undefined | Object;
  * @returns {Object|undefined} Parsed value
  */
 export declare function parseStructure(structureJson: Object): Object | undefined;
+/**
+ * Split a Swift command line, as printed by a verbose build or given in an
+ * environment variable, into arguments.
+ *
+ * Paths on Windows use backslash separators, so a backslash there is literal
+ * unless it precedes a double quote (the `CommandLineToArgvW` rules). Single
+ * quotes, which SwiftPM uses to quote arguments on every platform, keep their
+ * content literal. Elsewhere shell quoting applies.
+ *
+ * @param {String} commandString Command line
+ * @param {String} [platform] Platform name, defaults to process.platform
+ * @returns {Array<String>} Arguments
+ */
+export declare function splitSwiftCommandArgs(commandString: string, platform?: string): Array<string>;
 /**
  * Method to perform swift build in verbose mode.
  *
+ * `SWIFT_BUILD_ARGS` adds arguments to the build, for example
+ * `--build-system native` to use the llbuild engine with Swift 6.4.
+ *
  * @param {String} basePath Path
  * @returns {undefined|String} Verbose build output
  */
 export declare function verboseBuild(basePath: string): undefined | string;
 /**
- * Method to parse the verbose swift build output to identify key compiler parameters.
+ * Reduce one module's compiler invocation to the arguments that affect how
+ * its sources are type-checked.
+ *
+ * Only known argument classes are kept, so outputs, incremental build
+ * bookkeeping, response files, and flags a SourceKit build may not know are
+ * dropped. The order of the kept arguments is preserved, which keeps paired
+ * clang arguments such as `-Xcc -I -Xcc <path>` intact. The module cache is
+ * dropped as well: the build's cache may hold modules of other toolchains.
+ *
+ * @param {Array<String>} tokens Tokenized compiler invocation
+ * @returns {Array<String>} Sanitized compiler arguments
+ */
+export declare function sanitizeSwiftModuleArgs(tokens: Array<string>): Array<string>;
+/**
+ * Extract the per-module compiler invocations printed by a verbose swift
+ * build.
+ *
+ * Both engines print one driver invocation per module that carries
+ * `-module-name`: llbuild prints `swiftc ... -module-name X ... @sources`,
+ * while the Swift Build engine prints `builtin-SwiftDriver -- swiftc ...
+ * -module-name X ... @<target>.SwiftFileList`. llbuild also prints the
+ * frontend jobs of each module, which are only used when no driver line is
+ * found. Package manifest and plugin compilations are skipped.
+ *
+ * @param {String} buildOutput Verbose build output
+ * @param {String} [platform] Platform that printed the output, which decides
+ *   its quoting rules; defaults to process.platform
+ * @returns {Object} Map of module name to `{ args, sources, isDriver }`
+ */
+export declare function parseSwiftModuleInvocations(buildOutput: string, platform?: string): Object;
+/**
+ * Parse the llbuild engine's build description
+ * (`.build/<triple>/debug/description.json`).
+ *
+ * Its `swiftCommands` record every Swift module the build compiled, with the
+ * exact source list and compiler arguments. Host-tool variants
+ * (`...-tool.module`, built for macros and plugins) are used only when a
+ * module has no regular variant.
+ *
+ * @param {Object} descriptionJson Parsed description.json
+ * @returns {Object} Map of module name to `{ args, sources, isDriver }`
+ */
+export declare function parseSwiftBuildDescription(descriptionJson: Object): Object;
+/**
+ * Merge the sanitized arguments of several modules into one argument list,
+ * used when a source file cannot be attributed to a single module. The first
+ * module's single-value flags win, include paths accumulate, and `-Xcc`
+ * values are merged per clang argument group.
+ *
+ * @param {Array<Array<String>>} argLists Sanitized argument lists, most relevant first
+ * @returns {Array<String>} Merged arguments
+ */
+export declare function mergeSwiftModuleArgs(argLists: Array<Array<string>>): Array<string>;
+/**
+ * Method to parse the verbose swift build output to identify key compiler
+ * parameters. The arguments of the root package's modules are merged, or of
+ * every module when the root modules are unknown.
  *
  * @param {String} buildOutput Verbose build output
- * @returns {Object} compiler build parameters
+ * @param {Array<String>|Set<String>} [rootModules] Module names of the root package
+ * @returns {Object} `{ params, compilerArgs }` where params maps module names to their arguments
  */
-export declare function extractCompilerParamsFromBuild(buildOutput: string): Object;
+export declare function extractCompilerParamsFromBuild(buildOutput: string, rootModules?: Array<string> | Set<string>): Object;
 /**
  * Method to index a swift file and extract metadata
  *
  * @param {String} filePath Path to .swift file
- * @param {String|Array<string>} compilerArgs Compiler arguments extracted from verbose build log
+ * @param {String|Array<string>} compilerArgs Compiler arguments. They should
+ *   list every source of the file's module so that references across files
+ *   resolve; the file itself is appended when missing.
+ * @param {Object} [env] Environment overrides for sourcekitten
  * @returns {undefined|Object} metadata
  */
-export declare function index(filePath: string, compilerArgs: string | Array<string>): undefined | Object;
+export declare function index(filePath: string, compilerArgs: string | Array<string>, env?: Object): undefined | Object;
 /**
  * Parse the data from the index command
  *
+ * Besides the symbol names and lines, the unified symbol resolution (USR) of
+ * every indexed entity is recorded with its lines. A USR identifies the
+ * declaration the compiler resolved a reference to, including the module
+ * that declares it, which is what attributes a usage to a dependency.
+ *
  * @param {Object} indexJson Json from the index command
  * @returns {Object|undefined} Parsed value
  */
 export declare function parseIndex(indexJson: Object): Object | undefined;
+/**
+ * Identify the module that declares an entity from its demangled name.
+ *
+ * Qualified names start with the module (`Yams.dump(object:...)`), and
+ * members declared in extensions carry the extending module
+ * (`(extension in Yams):Swift.String.yaml`), which is what a usage of the
+ * member depends on.
+ *
+ * @param {String} demangled Output of `swift demangle --compact`
+ * @returns {undefined|String} Module name
+ */
+export declare function moduleFromDemangledName(demangled: string): undefined | string;
+/**
+ * Identify the module of a mangled Swift name without the demangler. Only the
+ * leading module context is decoded, so extension members are attributed to
+ * the extended type's module.
+ *
+ * @param {String} mangled Mangled name starting with `$s`
+ * @returns {undefined|String} Module name
+ */
+export declare function moduleFromMangledPrefix(mangled: string): undefined | string;
+/**
+ * Identify the declaring module of each USR.
+ *
+ * Swift USRs are demangled in one batch with `swift demangle`; clang module
+ * references (`c:@M@<module>`, emitted for import declarations) carry the
+ * module name directly. Other clang USRs name no module and are skipped.
+ *
+ * @param {Array<String>} usrs USRs to resolve
+ * @param {String} basePath Directory to run the demangler in
+ * @returns {Map<String, String>} USR to module name
+ */
+export declare function resolveUsrModules(usrs: Array<string>, basePath: string): Map<string, string>;
 /**
  * Method to execute dump-package package command.
  *
@@ -61,9 +231,10 @@ export declare function parseDumpPackage(dumpJson: Object): Object | undefined;
  *
  * @param {String} moduleName Module name
  * @param {String|Array<string>} compilerArgs Compiler arguments extracted from verbose build log
+ * @param {Object} [env] Environment overrides for sourcekitten
  * @returns {undefined|Object} JSON representation of the swift module or undefined.
  */
-export declare function moduleInfo(moduleName: string, compilerArgs: string | Array<string>): undefined | Object;
+export declare function moduleInfo(moduleName: string, compilerArgs: string | Array<string>, env?: Object): undefined | Object;
 /**
  * Parse the data from module-info command to replicate the swift interface
  *
@@ -72,32 +243,126 @@ export declare function moduleInfo(moduleName: string, compilerArgs: string | Ar
  */
 export declare function parseModuleInfo(moduleInfoJson: Object): Object | undefined;
 /**
- * Method to collect the build symbols from the output file maps generated by swift build.
+ * Method to collect the build symbols from the output file maps generated by
+ * swift build.
+ *
+ * Both build engines are supported: the llbuild engine writes per-module
+ * `output-file-map.json` files, while the Swift Build engine (default from
+ * Swift 6.4) writes per-target `<target>-OutputFileMap.json` files under
+ * `.build/out/Intermediates.noindex`.
  *
  * @param {String} basePath Path
  * @param {Object} options CLI options
- * @returns {Object} symbols map
+ * @param {Array<String>} [fileMaps] Output file maps, found under basePath when omitted
+ * @returns {Object} symbols map keyed by module name
  */
-export declare function collectBuildSymbols(basePath: string, options: Object): Object;
+export declare function collectBuildSymbols(basePath: string, options: Object, fileMaps?: Array<string>): Object;
 /**
- * Method to parse output file map to identify the module and their symbols.
- * This list is imprecise when compared with the data from module-info command.
+ * Method to parse output file map to identify the module, its sources, and
+ * their symbols. The symbol list is imprecise; the sources are exact.
+ *
+ * The module name is derived from the containing directory for llbuild maps
+ * (`<Module>.build` and, since Swift 6.4, `<Module>-tool.build`) and from the
+ * file name for Swift Build maps (`<target>-OutputFileMap.json`, where the
+ * target name still needs to be sanitised into a module name).
  *
  * @param filemap {String} File name
- * @returns {Object} parsed module metadata
+ * @returns {Object} parsed module metadata `{ moduleName, moduleSymbols, sourceFiles }`
  */
 export declare function parseOutputFileMap(filemap: string): Object;
+/**
+ * Parse `.build/workspace-state.json` into the dependency packages of the
+ * workspace and the directory each one was materialised in.
+ *
+ * @param {Object} stateJson Parsed workspace-state.json
+ * @param {String} basePath Root package directory
+ * @returns {Array<Object>} `{ identity, name, location, kind, dir }` per package
+ */
+export declare function parseSwiftWorkspaceState(stateJson: Object, basePath: string): Array<Object>;
+/**
+ * Parse the Swift Build engine's project model (`.build/manifest.pif`) into
+ * the module names each package declares.
+ *
+ * The manifest is a list of workspace, project, and target objects linked
+ * through their `signature` hashes. A project's guid is `PACKAGE:<identity>`
+ * and each target records its `PRODUCT_MODULE_NAME`. Unlike the verbose
+ * build output, the manifest lists modules whose compilation never started,
+ * which keeps the module-to-package mapping complete when a build fails.
+ *
+ * @param {Array} manifestJson Parsed manifest.pif contents
+ * @returns {Object} Map of package identity to module names
+ */
+export declare function parseSwiftBuildManifest(manifestJson: any[]): Object;
+/**
+ * Collect the modules imported by a Swift source file, with their lines.
+ *
+ * Declarations such as `@testable import Foo`, `public import Foo`,
+ * `@_implementationOnly import cmark_gfm`, and `import struct Foo.Bar` are
+ * recognised; comments, string literals, and `canImport` conditions are not
+ * imports.
+ *
+ * @param {String} sourceText Swift source
+ * @returns {Array<Object>} `{ module, line }` per import declaration
+ */
+export declare function parseSwiftImports(sourceText: string): Array<Object>;
+/**
+ * Collect the clang module names declared at the top level of a module map.
+ *
+ * @param {String} moduleMapText module.modulemap contents
+ * @returns {Object} `{ modules, headerPaths }`
+ */
+export declare function parseClangModuleMap(moduleMapText: string): Object;
+/**
+ * Build a description of every module in a completed swift build: its
+ * compiler arguments, sources, and owning package.
+ *
+ * Arguments come from the llbuild build description when present and from
+ * the verbose build output otherwise (the only source for the Swift Build
+ * engine); sources come from the same places or from the output file maps.
+ * Packages come from `workspace-state.json`, and every module is attributed
+ * to the package whose directory holds its sources. Clang modules are
+ * discovered through their module maps.
+ *
+ * @param {String} basePath Root package directory
+ * @param {String} buildOutput Verbose build output
+ * @param {Object} options CLI options
+ * @param {Object} [rootMetadata] Parsed dump-package of the root package
+ * @returns {Object} `{ modules, packages, root, clangModules, fileMaps }`
+ */
+export declare function collectSwiftBuildPlan(basePath: string, buildOutput: string, options: Object, rootMetadata?: Object): Object;
+/**
+ * Check that sourcekitten can load SourceKit, with a trivial syntax request.
+ *
+ * A missing binary, a binary without its Swift runtime (`error while loading
+ * shared libraries: libswiftCore.so`), or one linked against a different
+ * Swift runtime than the toolchain provides (Linux has no stable Swift ABI, so
+ * such a binary crashes inside libswiftCore) fails every request; the probe
+ * turns that into one clear message instead of silent empty results.
+ *
+ * @param {Object} [env] Environment overrides for sourcekitten
+ * @returns {boolean} `true` when sourcekitten answered the probe
+ */
+export declare function isSourcekittenUsable(env?: Object): boolean;
 /**
  * Create a precise semantics slices file for a swift project.
  *
+ * The project is built once in verbose mode. Every source file of the root
+ * package's (non-test) modules is then indexed with sourcekitten using that
+ * module's own compiler arguments and source list, with sourcekitten aligned
+ * to the toolchain that compiled the project. The declaring module of every
+ * resolved reference is recovered from its USR, which attributes each usage
+ * to the package that provides the module (`moduleReferences`).
+ *
  * @param basePath basePath Path
  * @param options options CLI options
  */
 export declare function createSemanticsSlices(basePath: any, options: any): {
+    projectPath: any;
+    toolchain: any;
     packageMetadata: Object | undefined;
+    packages: any;
+    packageModules: {};
     buildSymbols: Object;
-    moduleInfos: {};
-    fileStructures: {};
     fileIndexes: {};
 } | undefined;
 //# sourceMappingURL=swiftsem.d.ts.map

package/types/lib/evinser/swiftsem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swiftsem.d.ts","sourceRoot":"","sources":["../../../lib/evinser/swiftsem.js"],"names":[],"mappings":"AAwEA;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,QAAQ,QAAA,GAFxB,SAAS,GAAC,MAAM,CAI5B;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,aAAa,EAHjC,MAGiC,GAF/B,MAAM,GAAC,SAAS,CAiB5B;AAqCD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,QAAQ,QAAA,GAFxB,SAAS,SAAO,CAa5B;AAED;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAAC,WAAW,QAAA,GAF7C,MAAM,CA+JlB;AAED;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,QAAQ,QAAA,EAAE,YAAY,EAHjC,SAAO,KAAK,CAAC,MAAM,CAGc,GAF/B,SAAS,GAAC,MAAM,CAc5B;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAHzB,MAGyB,GAFvB,MAAM,GAAC,SAAS,CA6B5B;AAsED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,QAAQ,QAAA,GAFvB,SAAS,GAAC,MAAM,CAY5B;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAH9B,MAG8B,GAF5B,MAAM,GAAC,SAAS,CA4B5B;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,UAAU,QAAA,EAAE,YAAY,EAHxC,SAAO,KAAK,CAAC,MAAM,CAGqB,GAFtC,SAAS,GAAC,MAAM,CAa5B;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,cAAc,EAHnC,MAGmC,GAFjC,MAAM,GAAC,SAAS,CAqF5B;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,QAAA,EAAE,OAAO,EAH1C,MAG0C,GAFxC,MAAM,CAkBlB;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,QAAA,GAF7B,MAAM,CAgBlB;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,KAAA,EAAE,OAAO,KAAA;;;;;;cAoGtD"}
+{"version":3,"file":"swiftsem.d.ts","sourceRoot":"","sources":["../../../lib/evinser/swiftsem.js"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,87 @@
+/**
+ * The purl type used for installed agentic CLI tools. These tools ship as
+ * self-contained executables rather than as a resolvable source package, so a
+ * `pkg:generic/...` identifier is the honest representation.
+ */
+export declare const AGENTIC_TOOL_PURL_TYPE = "generic";
+/**
+ * Rewrite an absolute path under the user's home directory to a `~`-relative
+ * form so the emitted BOM does not carry the local username.
+ *
+ * @param {string} filePath Absolute path
+ * @returns {string} Home-relative path when applicable, else the input
+ */
+export declare function redactHomePath(filePath: string): string;
+/**
+ * Describe where each supported agentic CLI tool stores its per-user state.
+ *
+ * Each entry lists the tool key, a display name, and the candidate home
+ * directories per platform (mirroring how `getIdeExtensionDirs` models IDE
+ * extension locations). Only the current platform's directories plus
+ * always-present dot-directories are included.
+ *
+ * @returns {Array<{tool: string, name: string, dirs: string[], supportDirs?: string[]}>}
+ *   One entry per known agentic CLI tool.
+ */
+export declare function getAgenticToolDirs(): Array<{
+    tool: string;
+    name: string;
+    dirs: string[];
+    supportDirs?: string[];
+}>;
+/**
+ * Discover which agentic CLI tools are installed for the current user by
+ * checking their known home directories.
+ *
+ * @returns {Array<{tool: string, name: string, dir: string, supportDir?: string}>}
+ *   One entry per discovered tool, using the first existing directory.
+ */
+export declare function discoverAgenticTools(): Array<{
+    tool: string;
+    name: string;
+    dir: string;
+    supportDir?: string;
+}>;
+/**
+ * Compute safe, redacted signal counts for a discovered tool. Only structural
+ * counts and small enumerated values are returned; no credential, transcript,
+ * or telemetry content is read.
+ *
+ * @param {string} tool Tool key
+ * @param {string} dir Discovered tool home directory
+ * @param {string} [supportDir] Optional platform support directory
+ * @returns {Object} Map of signal name to count/boolean/small-string value
+ */
+export declare function collectToolSignals(tool: string, dir: string, supportDir?: string): Object;
+/**
+ * Build a CycloneDX application component for one discovered agentic tool.
+ *
+ * @param {{tool: string, name: string, dir: string, supportDir?: string}} entry
+ *   Discovered tool entry
+ * @returns {Object} CycloneDX component
+ */
+export declare function componentForAgenticTool(entry: {
+    tool: string;
+    name: string;
+    dir: string;
+    supportDir?: string;
+}): Object;
+/**
+ * Discover installed agentic CLI tools on the current host and return CycloneDX
+ * components describing each one, plus the child agents, plugins, and providers
+ * they define and the dependency edges linking children to their tool.
+ *
+ * This host scan is unconditional: it does not consult scan filters such as
+ * `--exclude` or profile/technique options, because it inventories fixed tool
+ * home directories rather than a project tree. The `options` argument is
+ * accepted for signature parity and is intentionally not used to alter results.
+ *
+ * @param {Object} [options={}] Collection options (accepted but not applied)
+ * @returns {{components: Object[], services: Object[], dependencies: Object[]}} Discovered inventory
+ */
+export declare function collectAgenticTools(_options?: {}): {
+    components: Object[];
+    services: Object[];
+    dependencies: Object[];
+};
+//# sourceMappingURL=agenticToolutils.d.ts.map