@trustify-da/trustify-da-javascript-client 0.3.0-ea.7281b26 → 0.3.0-ea.76e1fef

package/dist/src/providers/python_controller.js

@@ -19,7 +19,7 @@ function getPipShowOutput(depNames) {
         throw new Error('fail invoking \'pip show\' to fetch metadata for all installed packages in environment', { cause: error });
     }
 }
-/** @typedef {{name: string, version: string, dependencies: DependencyEntry[]}} DependencyEntry */
+/** @typedef {{name: string, version: string, dependencies: DependencyEntry[], hashes?: Array<{alg: string, content: string}>}} DependencyEntry */
 export default class Python_controller {
     pythonEnvDir;
     pathToPipBin;
@@ -95,7 +95,7 @@ export default class Python_controller {
     }
     /**
      * Parse the requirements.txt file using tree-sitter and return structured requirement data.
-     * @return {Promise<{name: string, version: string|null}[]>}
+     * @return {Promise<{name: string, version: string|null, hasMarker: boolean}[]>}
      */
     async #parseRequirements() {
         const content = fs.readFileSync(this.pathToRequirements).toString();
@@ -107,7 +107,8 @@ export default class Python_controller {
             const version = versionMatches.length > 0
                 ? versionMatches[0].captures.find(c => c.name === 'version').node.text
                 : null;
-            return { name, version };
+            const hasMarker = reqNode.children.some(c => c.type === 'marker_spec');
+            return { name, version, hasMarker };
         }));
     }
     #decideIfWindowsOrLinuxPath(fileName) {
@@ -224,7 +225,10 @@ export default class Python_controller {
                 CachedEnvironmentDeps[packageName.replace("_", "-")] = pipDepTreeEntryForCache;
             });
         }
-        parsedRequirements.forEach(({ name: depName, version: manifestVersion }) => {
+        parsedRequirements.forEach(({ name: depName, version: manifestVersion, hasMarker }) => {
+            if (hasMarker && CachedEnvironmentDeps[depName.toLowerCase()] === undefined) {
+                return;
+            }
             if (matchManifestVersions === "true" && manifestVersion != null) {
                 let installedVersion;
                 if (CachedEnvironmentDeps[depName.toLowerCase()] !== undefined) {

package/dist/src/providers/python_pip.d.ts

@@ -10,6 +10,10 @@ export type DependencyEntry = {
     name: string;
     version: string;
     dependencies: DependencyEntry[];
+    hashes?: Array<{
+        alg: string;
+        content: string;
+    }>;
 };
 /**
  * @param {string} manifestName - the subject manifest name-type

package/dist/src/providers/python_pip.js

@@ -6,12 +6,13 @@ import { environmentVariableIsPopulated, getCustom, getCustomPath, invokeCommand
 import Python_controller from './python_controller.js';
 import { getParser, getIgnoreQuery, getPinnedVersionQuery } from './requirements_parser.js';
 export default { isSupported, validateLockFile, provideComponent, provideStack, readLicenseFromManifest };
-/** @typedef {{name: string, version: string, dependencies: DependencyEntry[]}} DependencyEntry */
+/** @typedef {{name: string, version: string, dependencies: DependencyEntry[], hashes?: Array<{alg: string, content: string}>}} DependencyEntry */
 /**
  * @type {string} ecosystem for python-pip is 'pip'
  * @private
  */
 const ecosystem = 'pip';
+const NO_SCOPE = undefined;
 /**
  * @param {string} manifestName - the subject manifest name-type
  * @returns {boolean} - return true if `requirements.txt` is the manifest name-type
@@ -56,7 +57,6 @@ async function provideComponent(manifest, opts = {}) {
         contentType: 'application/vnd.cyclonedx+json'
     };
 }
-/** @typedef {{name: string, , version: string, dependencies: DependencyEntry[]}} DependencyEntry */
 /**
  *
  * @param {PackageURL}source
@@ -66,7 +66,7 @@ async function provideComponent(manifest, opts = {}) {
  */
 function addAllDependencies(source, dep, sbom) {
     let targetPurl = toPurl(dep["name"], dep["version"]);
-    sbom.addDependency(source, targetPurl);
+    sbom.addDependency(source, targetPurl, NO_SCOPE, dep["hashes"]);
     let directDeps = dep["dependencies"];
     if (directDeps !== undefined && directDeps.length > 0) {
         directDeps.forEach((dependency) => { addAllDependencies(toPurl(dep["name"], dep["version"]), dependency, sbom); });
@@ -202,7 +202,7 @@ async function getSbomForComponentAnalysis(manifest, opts = {}) {
     const license = readLicenseFromManifest(manifest);
     sbom.addRoot(rootPurl, license);
     dependencies.forEach(dep => {
-        sbom.addDependency(rootPurl, toPurl(dep.name, dep.version));
+        sbom.addDependency(rootPurl, toPurl(dep.name, dep.version), NO_SCOPE, dep.hashes);
     });
     await handleIgnoredDependencies(manifest, sbom, opts);
     // In python there is no root component, then we must remove the dummy root we added, so the sbom json will be accepted by the DA backend

package/dist/src/providers/python_pip_pyproject.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Python provider for pyproject.toml files using PEP 621 format without a lock file.
+ * Uses `pip install --dry-run --ignore-installed --report` to resolve the full dependency tree.
+ * Acts as the fallback provider when no lock file (uv.lock/poetry.lock) is found.
+ */
+export default class Python_pip_pyproject extends Base_pyproject {
+    /**
+     * Always returns true — pip provider is the fallback when no lock file is found.
+     * @param {string} manifestDir
+     * @param {{}} [opts={}]
+     * @returns {boolean}
+     */
+    validateLockFile(manifestDir: string, opts?: {}): boolean;
+    /**
+     * Get pip report output from env var override or by running pip.
+     * @param {string} manifestDir - directory containing pyproject.toml
+     * @param {{}} [opts={}]
+     * @returns {string} pip report JSON string
+     */
+    _getPipReportOutput(manifestDir: string, opts?: {}): string;
+    /**
+     * Parse pip report JSON and build dependency graph.
+     * @param {string} reportJson - pip report JSON string
+     * @returns {{directDeps: string[], graph: Map<string, {name: string, version: string, children: string[]}>}}
+     */
+    _parsePipReport(reportJson: string): {
+        directDeps: string[];
+        graph: Map<string, {
+            name: string;
+            version: string;
+            children: string[];
+        }>;
+    };
+    /**
+     * Check if a requires_dist entry is an extras-only dependency.
+     * @param {string} req - e.g. "PySocks!=1.5.7,>=1.5.6; extra == \"socks\""
+     * @returns {boolean}
+     */
+    _hasExtraMarker(req: string): boolean;
+    /**
+     * Extract package name from a requires_dist entry.
+     * @param {string} req - e.g. "charset_normalizer<4,>=2"
+     * @returns {string|null}
+     */
+    _extractDepName(req: string): string | null;
+    /**
+     * Resolve dependencies using pip install --dry-run --report.
+     * @param {string} manifestDir
+     * @param {string} _workspaceDir - unused (pip resolves from manifest directory)
+     * @param {object} parsed - parsed pyproject.toml
+     * @param {{}} [opts={}]
+     * @returns {Promise<{directDeps: string[], graph: Map}>}
+     */
+    _getDependencyData(manifestDir: string, _workspaceDir: string, parsed: object, opts?: {}): Promise<{
+        directDeps: string[];
+        graph: Map<any, any>;
+    }>;
+    _findEggInfoDirs(dir: any): string[];
+    _cleanupEggInfo(dir: any, existing: any): void;
+}
+import Base_pyproject from './base_pyproject.js';

package/dist/src/providers/python_pip_pyproject.js

@@ -0,0 +1,144 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { environmentVariableIsPopulated, getCustomPath, invokeCommand } from '../tools.js';
+import Base_pyproject from './base_pyproject.js';
+/**
+ * Python provider for pyproject.toml files using PEP 621 format without a lock file.
+ * Uses `pip install --dry-run --ignore-installed --report` to resolve the full dependency tree.
+ * Acts as the fallback provider when no lock file (uv.lock/poetry.lock) is found.
+ */
+export default class Python_pip_pyproject extends Base_pyproject {
+    /** @returns {string} */
+    _lockFileName() {
+        return '.pip-lock-nonexistent';
+    }
+    /** @returns {string} */
+    _cmdName() {
+        return 'pip';
+    }
+    /**
+     * Always returns true — pip provider is the fallback when no lock file is found.
+     * @param {string} manifestDir
+     * @param {{}} [opts={}]
+     * @returns {boolean}
+     */
+    // eslint-disable-next-line no-unused-vars
+    validateLockFile(manifestDir, opts = {}) {
+        return true;
+    }
+    /**
+     * Get pip report output from env var override or by running pip.
+     * @param {string} manifestDir - directory containing pyproject.toml
+     * @param {{}} [opts={}]
+     * @returns {string} pip report JSON string
+     */
+    _getPipReportOutput(manifestDir, opts) {
+        if (environmentVariableIsPopulated('TRUSTIFY_DA_PIP_REPORT')) {
+            return Buffer.from(process.env['TRUSTIFY_DA_PIP_REPORT'], 'base64').toString('ascii');
+        }
+        let pipBin = getCustomPath('pip3', opts);
+        try {
+            invokeCommand(pipBin, ['--version']);
+        }
+        catch {
+            pipBin = getCustomPath('pip', opts);
+        }
+        let eggInfoDirs = this._findEggInfoDirs(manifestDir);
+        let result = invokeCommand(pipBin, [
+            'install', '--dry-run', '--ignore-installed', '--quiet', '--report', '-', '.'
+        ], { cwd: manifestDir }).toString();
+        this._cleanupEggInfo(manifestDir, eggInfoDirs);
+        return result;
+    }
+    /**
+     * Parse pip report JSON and build dependency graph.
+     * @param {string} reportJson - pip report JSON string
+     * @returns {{directDeps: string[], graph: Map<string, {name: string, version: string, children: string[]}>}}
+     */
+    _parsePipReport(reportJson) {
+        let report = JSON.parse(reportJson);
+        let packages = report.install || [];
+        let rootEntry = packages.find(p => p.download_info?.dir_info !== undefined);
+        let rootRequires = rootEntry?.metadata?.requires_dist || [];
+        let directDepNames = new Set();
+        for (let req of rootRequires) {
+            if (this._hasExtraMarker(req)) {
+                continue;
+            }
+            let name = this._extractDepName(req);
+            if (name) {
+                directDepNames.add(this._canonicalize(name));
+            }
+        }
+        let graph = new Map();
+        let nonRootPackages = packages.filter(p => p !== rootEntry);
+        for (let pkg of nonRootPackages) {
+            let name = pkg.metadata.name;
+            let version = pkg.metadata.version;
+            let key = this._canonicalize(name);
+            graph.set(key, { name, version, children: [] });
+        }
+        for (let pkg of nonRootPackages) {
+            let key = this._canonicalize(pkg.metadata.name);
+            let entry = graph.get(key);
+            let requires = pkg.metadata.requires_dist || [];
+            for (let req of requires) {
+                let depName = this._extractDepName(req);
+                if (!depName) {
+                    continue;
+                }
+                let depKey = this._canonicalize(depName);
+                if (graph.has(depKey)) {
+                    entry.children.push(depKey);
+                }
+            }
+        }
+        let directDeps = [...directDepNames].filter(key => graph.has(key));
+        return { directDeps, graph };
+    }
+    /**
+     * Check if a requires_dist entry is an extras-only dependency.
+     * @param {string} req - e.g. "PySocks!=1.5.7,>=1.5.6; extra == \"socks\""
+     * @returns {boolean}
+     */
+    _hasExtraMarker(req) {
+        return /;\s*.*extra\s*==/.test(req);
+    }
+    /**
+     * Extract package name from a requires_dist entry.
+     * @param {string} req - e.g. "charset_normalizer<4,>=2"
+     * @returns {string|null}
+     */
+    _extractDepName(req) {
+        let match = req.match(/^([A-Za-z0-9]([A-Za-z0-9._-]*[A-Za-z0-9])?)/);
+        return match ? match[1] : null;
+    }
+    /**
+     * Resolve dependencies using pip install --dry-run --report.
+     * @param {string} manifestDir
+     * @param {string} _workspaceDir - unused (pip resolves from manifest directory)
+     * @param {object} parsed - parsed pyproject.toml
+     * @param {{}} [opts={}]
+     * @returns {Promise<{directDeps: string[], graph: Map}>}
+     */
+    // eslint-disable-next-line no-unused-vars
+    async _getDependencyData(manifestDir, _workspaceDir, parsed, opts) {
+        let reportOutput = this._getPipReportOutput(manifestDir, opts);
+        return this._parsePipReport(reportOutput);
+    }
+    _findEggInfoDirs(dir) {
+        try {
+            return fs.readdirSync(dir).filter(f => f.endsWith('.egg-info'));
+        }
+        catch {
+            return [];
+        }
+    }
+    _cleanupEggInfo(dir, existing) {
+        for (let entry of this._findEggInfoDirs(dir)) {
+            if (!existing.includes(entry)) {
+                fs.rmSync(path.join(dir, entry), { recursive: true, force: true });
+            }
+        }
+    }
+}

package/dist/src/providers/python_poetry.d.ts

@@ -1,11 +1,27 @@
 export default class Python_poetry extends Base_pyproject {
+    /**
+     * @param {string} manifestDir
+     * @param {string} _workspaceDir - unused (poetry has no workspace support)
+     * @param {object} parsed - parsed pyproject.toml
+     * @param {Object} opts
+     * @returns {Promise<{directDeps: string[], graph: Map<string, {name: string, version: string, children: string[]}>}>}
+     */
+    _getDependencyData(manifestDir: string, _workspaceDir: string, parsed: object, opts: any): Promise<{
+        directDeps: string[];
+        graph: Map<string, {
+            name: string;
+            version: string;
+            children: string[];
+        }>;
+    }>;
     /**
      * Get poetry show --tree output.
      * @param {string} manifestDir
+     * @param {boolean} hasDevGroup
      * @param {Object} opts
      * @returns {string}
      */
-    _getPoetryShowTreeOutput(manifestDir: string, opts: any): string;
+    _getPoetryShowTreeOutput(manifestDir: string, hasDevGroup: boolean, opts: any): string;
     /**
      * Get poetry show --all output (flat list with resolved versions).
      * @param {string} manifestDir
@@ -21,16 +37,33 @@ export default class Python_poetry extends Base_pyproject {
      * @returns {Map<string, string>} canonical name -> version
      */
     _parsePoetryShowAll(output: string): Map<string, string>;
+    /**
+     * Collects PEP 508 marker expressions for direct and transitive deps.
+     * Direct markers come from pyproject.toml dependency strings, e.g.:
+     *   "pywin32>=311 ; sys_platform == 'win32'"  → directMarkers['pywin32'] = "sys_platform == 'win32'"
+     * Transitive markers come from poetry.lock [package.dependencies] entries, e.g.:
+     *   colorama = {version = "*", markers = "sys_platform == 'win32'"}
+     *   → transitiveMarkers['click']['colorama'] = "sys_platform == 'win32'"
+     * @param {string|null} lockDir
+     * @param {object} parsed - parsed pyproject.toml
+     * @returns {{directMarkers: Map<string, string>, transitiveMarkers: Map<string, Map<string, string>>}}
+     */
+    _extractMarkerData(lockDir: string | null, parsed: object): {
+        directMarkers: Map<string, string>;
+        transitiveMarkers: Map<string, Map<string, string>>;
+    };
     /**
      * Parse poetry show --tree output into a dependency graph structure.
-     * Top-level lines (no indentation/tree chars) are direct deps: "name version description"
-     * Indented lines are transitive deps with tree chars: "├── name >=constraint"
      *
      * @param {string} treeOutput
      * @param {Map<string, string>} versionMap - canonical name -> resolved version
+     * @param {{directMarkers: Map<string, string>, transitiveMarkers: Map<string, Map<string, string>>}} markerData
      * @returns {{directDeps: string[], graph: Map<string, {name: string, version: string, children: string[]}>}}
      */
-    _parsePoetryTree(treeOutput: string, versionMap: Map<string, string>): {
+    _parsePoetryTree(treeOutput: string, versionMap: Map<string, string>, markerData: {
+        directMarkers: Map<string, string>;
+        transitiveMarkers: Map<string, Map<string, string>>;
+    }): {
         directDeps: string[];
         graph: Map<string, {
             name: string;

package/dist/src/providers/python_poetry.js

@@ -1,7 +1,9 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { parse as parseToml } from 'smol-toml';
 import { environmentVariableIsPopulated, getCustom, getCustomPath, invokeCommand } from '../tools.js';
 import Base_pyproject from './base_pyproject.js';
+import { evaluateMarker } from './marker_evaluator.js';
 export default class Python_poetry extends Base_pyproject {
     /**
      * Poetry has no native workspace/monorepo support (python-poetry/poetry#2270).
@@ -39,23 +41,31 @@ export default class Python_poetry extends Base_pyproject {
      */
     // eslint-disable-next-line no-unused-vars
     async _getDependencyData(manifestDir, _workspaceDir, parsed, opts) {
-        let treeOutput = this._getPoetryShowTreeOutput(manifestDir, opts);
+        let hasDevGroup = !!(parsed.tool?.poetry?.group?.dev || parsed.tool?.poetry?.['dev-dependencies']);
+        let treeOutput = this._getPoetryShowTreeOutput(manifestDir, hasDevGroup, opts);
         let showAllOutput = this._getPoetryShowAllOutput(manifestDir, opts);
         let versionMap = this._parsePoetryShowAll(showAllOutput);
-        return this._parsePoetryTree(treeOutput, versionMap);
+        let lockDir = this._findLockFileDir(manifestDir, opts);
+        let markerData = this._extractMarkerData(lockDir, parsed);
+        return this._parsePoetryTree(treeOutput, versionMap, markerData);
     }
     /**
      * Get poetry show --tree output.
      * @param {string} manifestDir
+     * @param {boolean} hasDevGroup
      * @param {Object} opts
      * @returns {string}
      */
-    _getPoetryShowTreeOutput(manifestDir, opts) {
+    _getPoetryShowTreeOutput(manifestDir, hasDevGroup, opts) {
         if (environmentVariableIsPopulated('TRUSTIFY_DA_POETRY_SHOW_TREE')) {
             return Buffer.from(process.env['TRUSTIFY_DA_POETRY_SHOW_TREE'], 'base64').toString('utf-8');
         }
         let poetryBin = getCustomPath('poetry', opts);
-        return invokeCommand(poetryBin, ['show', '--tree', '--no-ansi'], { cwd: manifestDir }).toString();
+        let args = ['show', '--tree', '--no-ansi'];
+        if (hasDevGroup) {
+            args.push('--without', 'dev');
+        }
+        return invokeCommand(poetryBin, args, { cwd: manifestDir }).toString();
     }
     /**
      * Get poetry show --all output (flat list with resolved versions).
@@ -92,16 +102,60 @@ export default class Python_poetry extends Base_pyproject {
         }
         return versions;
     }
+    /**
+     * Collects PEP 508 marker expressions for direct and transitive deps.
+     * Direct markers come from pyproject.toml dependency strings, e.g.:
+     *   "pywin32>=311 ; sys_platform == 'win32'"  → directMarkers['pywin32'] = "sys_platform == 'win32'"
+     * Transitive markers come from poetry.lock [package.dependencies] entries, e.g.:
+     *   colorama = {version = "*", markers = "sys_platform == 'win32'"}
+     *   → transitiveMarkers['click']['colorama'] = "sys_platform == 'win32'"
+     * @param {string|null} lockDir
+     * @param {object} parsed - parsed pyproject.toml
+     * @returns {{directMarkers: Map<string, string>, transitiveMarkers: Map<string, Map<string, string>>}}
+     */
+    _extractMarkerData(lockDir, parsed) {
+        let directMarkers = new Map();
+        let transitiveMarkers = new Map();
+        // Extract markers from PEP 621 dependency strings: "name[extras]>=ver ; marker"
+        let deps = parsed.project?.dependencies || [];
+        for (let dep of deps) {
+            let m = dep.match(/^([A-Za-z0-9][A-Za-z0-9._-]*)\s*[^;]*;\s*(.+)$/);
+            if (m) {
+                directMarkers.set(this._canonicalize(m[1]), m[2].trim());
+            }
+        }
+        if (lockDir) {
+            let lockPath = path.join(lockDir, this._lockFileName());
+            if (fs.existsSync(lockPath)) {
+                let lockContent = fs.readFileSync(lockPath, 'utf-8');
+                let lock = parseToml(lockContent);
+                let packages = lock.package || [];
+                for (let pkg of packages) {
+                    let pkgKey = this._canonicalize(pkg.name);
+                    let pkgDeps = pkg.dependencies || {};
+                    for (let [depName, depSpec] of Object.entries(pkgDeps)) {
+                        let markers = typeof depSpec === 'object' && depSpec != null ? depSpec.markers : null;
+                        if (markers) {
+                            if (!transitiveMarkers.has(pkgKey)) {
+                                transitiveMarkers.set(pkgKey, new Map());
+                            }
+                            transitiveMarkers.get(pkgKey).set(this._canonicalize(depName), markers);
+                        }
+                    }
+                }
+            }
+        }
+        return { directMarkers, transitiveMarkers };
+    }
     /**
      * Parse poetry show --tree output into a dependency graph structure.
-     * Top-level lines (no indentation/tree chars) are direct deps: "name version description"
-     * Indented lines are transitive deps with tree chars: "├── name >=constraint"
      *
      * @param {string} treeOutput
      * @param {Map<string, string>} versionMap - canonical name -> resolved version
+     * @param {{directMarkers: Map<string, string>, transitiveMarkers: Map<string, Map<string, string>>}} markerData
      * @returns {{directDeps: string[], graph: Map<string, {name: string, version: string, children: string[]}>}}
      */
-    _parsePoetryTree(treeOutput, versionMap) {
+    _parsePoetryTree(treeOutput, versionMap, markerData) {
         let lines = treeOutput.split(/\r?\n/);
         let graph = new Map();
         let directDeps = [];
@@ -117,6 +171,12 @@ export default class Python_poetry extends Base_pyproject {
                 let name = topMatch[1];
                 let version = topMatch[2];
                 let key = this._canonicalize(name);
+                let marker = markerData.directMarkers.get(key);
+                if (marker && !evaluateMarker(marker)) {
+                    currentDirectDep = null;
+                    stack = [];
+                    continue;
+                }
                 directDeps.push(key);
                 if (!graph.has(key)) {
                     graph.set(key, { name, version, children: [] });
@@ -143,6 +203,20 @@ export default class Python_poetry extends Base_pyproject {
             // determine depth by counting tree-drawing groups in the prefix
             let prefix = line.substring(0, nameStart);
             let depth = (prefix.match(/(?:[├└│ ][\s─]{2} ?)/g) || []).length;
+            // pop stack back to find the parent at depth-1
+            while (stack.length > 0 && stack[stack.length - 1].depth >= depth) {
+                stack.pop();
+            }
+            let parentKey = stack.length > 0 ? stack[stack.length - 1].key : null;
+            if (parentKey) {
+                let parentMarkers = markerData.transitiveMarkers.get(parentKey);
+                if (parentMarkers) {
+                    let marker = parentMarkers.get(depKey);
+                    if (marker && !evaluateMarker(marker)) {
+                        continue;
+                    }
+                }
+            }
             // resolve version from the version map
             let version = versionMap.get(depKey) || null;
             if (!version) {
@@ -151,12 +225,7 @@ export default class Python_poetry extends Base_pyproject {
             if (!graph.has(depKey)) {
                 graph.set(depKey, { name: depName, version, children: [] });
             }
-            // pop stack back to find the parent at depth-1
-            while (stack.length > 0 && stack[stack.length - 1].depth >= depth) {
-                stack.pop();
-            }
-            if (stack.length > 0) {
-                let parentKey = stack[stack.length - 1].key;
+            if (parentKey) {
                 let parentEntry = graph.get(parentKey);
                 if (parentEntry && !parentEntry.children.includes(depKey)) {
                     parentEntry.children.push(depKey);

package/dist/src/providers/python_uv.d.ts

@@ -1,4 +1,32 @@
+/**
+ * Discover all pyproject.toml manifest paths in a uv workspace.
+ * Parses `[tool.uv.workspace]` from root pyproject.toml and glob-expands member patterns.
+ *
+ * @param {string} workspaceRoot - Absolute or relative path to workspace root (must contain pyproject.toml and uv.lock)
+ * @param {{ workspaceDiscoveryIgnore?: string[], TRUSTIFY_DA_WORKSPACE_DISCOVERY_IGNORE?: string, [key: string]: unknown }} [opts={}]
+ * @returns {Promise<string[]>} Paths to pyproject.toml files (absolute)
+ */
+export function discoverUvWorkspaceMembers(workspaceRoot: string, opts?: {
+    workspaceDiscoveryIgnore?: string[];
+    TRUSTIFY_DA_WORKSPACE_DISCOVERY_IGNORE?: string;
+    [key: string]: unknown;
+}): Promise<string[]>;
 export default class Python_uv extends Base_pyproject {
+    /**
+     * @param {string} manifestDir - directory containing the target pyproject.toml
+     * @param {string} workspaceDir - workspace root (for resolving editable install paths)
+     * @param {object} parsed - parsed pyproject.toml
+     * @param {Object} opts
+     * @returns {Promise<{directDeps: string[], graph: Map<string, {name: string, version: string, children: string[]}>}>}
+     */
+    _getDependencyData(manifestDir: string, workspaceDir: string, parsed: object, opts: any): Promise<{
+        directDeps: string[];
+        graph: Map<string, {
+            name: string;
+            version: string;
+            children: string[];
+        }>;
+    }>;
     /**
      * Get the uv export output, either from env var or by running the command.
      * @param {string} manifestDir

package/dist/src/providers/python_uv.js

@@ -1,8 +1,11 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import fg from 'fast-glob';
 import { parse as parseToml } from 'smol-toml';
 import { environmentVariableIsPopulated, getCustomPath, invokeCommand } from '../tools.js';
+import { filterManifestPathsByDiscoveryIgnore, resolveWorkspaceDiscoveryIgnore, toManifestGlobPatterns } from '../workspace.js';
 import Base_pyproject from './base_pyproject.js';
+import { evaluateMarker } from './marker_evaluator.js';
 import { getParser, getPinnedVersionQuery } from './requirements_parser.js';
 export default class Python_uv extends Base_pyproject {
     /** @returns {string} */
@@ -36,7 +39,7 @@ export default class Python_uv extends Base_pyproject {
             return Buffer.from(process.env['TRUSTIFY_DA_UV_EXPORT'], 'base64').toString('ascii');
         }
         let uvBin = getCustomPath('uv', opts);
-        return invokeCommand(uvBin, ['export', '--format', 'requirements.txt', '--frozen', '--no-hashes'], { cwd: manifestDir }).toString();
+        return invokeCommand(uvBin, ['export', '--format', 'requirements.txt', '--frozen', '--no-hashes', '--no-dev', '--no-emit-project'], { cwd: manifestDir }).toString();
     }
     /**
      * Parse uv export output into a dependency graph using tree-sitter-requirements
@@ -70,6 +73,9 @@ export default class Python_uv extends Base_pyproject {
                         let version = memberParsed.project?.version || memberParsed.tool?.poetry?.version;
                         if (name && version) {
                             let key = this._canonicalize(name);
+                            if (key === canonProjectName) {
+                                continue;
+                            }
                             currentPkg = { name, version, parents: new Set() };
                             packages.set(key, currentPkg);
                             collectingVia = false;
@@ -86,6 +92,16 @@ export default class Python_uv extends Base_pyproject {
                 if (!nameNode) {
                     continue;
                 }
+                // Skip packages with non-matching PEP 508 markers, e.g. "pywin32==311 ; sys_platform == 'win32'"
+                let markerNode = child.children.find(c => c.type === 'marker_spec');
+                if (markerNode) {
+                    let markerText = markerNode.text.replace(/^\s*;\s*/, '');
+                    if (!evaluateMarker(markerText)) {
+                        currentPkg = null;
+                        collectingVia = false;
+                        continue;
+                    }
+                }
                 let name = nameNode.text;
                 let version = null;
                 let versionMatches = pinnedVersionQuery.matches(child);
@@ -144,3 +160,68 @@ export default class Python_uv extends Base_pyproject {
         return { directDeps, graph };
     }
 }
+const DEFAULT_UV_DISCOVERY_IGNORE = [
+    '**/__pycache__/**',
+    '**/.venv/**',
+];
+/**
+ * Discover all pyproject.toml manifest paths in a uv workspace.
+ * Parses `[tool.uv.workspace]` from root pyproject.toml and glob-expands member patterns.
+ *
+ * @param {string} workspaceRoot - Absolute or relative path to workspace root (must contain pyproject.toml and uv.lock)
+ * @param {{ workspaceDiscoveryIgnore?: string[], TRUSTIFY_DA_WORKSPACE_DISCOVERY_IGNORE?: string, [key: string]: unknown }} [opts={}]
+ * @returns {Promise<string[]>} Paths to pyproject.toml files (absolute)
+ */
+export async function discoverUvWorkspaceMembers(workspaceRoot, opts = {}) {
+    const root = path.resolve(workspaceRoot);
+    const rootPyproject = path.join(root, 'pyproject.toml');
+    const uvLock = path.join(root, 'uv.lock');
+    if (!fs.existsSync(rootPyproject) || !fs.existsSync(uvLock)) {
+        return [];
+    }
+    let parsed;
+    try {
+        parsed = parseToml(fs.readFileSync(rootPyproject, 'utf-8'));
+    }
+    catch {
+        return [];
+    }
+    const workspaceConfig = parsed?.tool?.uv?.workspace;
+    if (!workspaceConfig) {
+        return [];
+    }
+    const memberPatterns = workspaceConfig.members;
+    if (!Array.isArray(memberPatterns) || memberPatterns.length === 0) {
+        return [];
+    }
+    const excludePatterns = Array.isArray(workspaceConfig.exclude) ? workspaceConfig.exclude : [];
+    const excludeGlobs = excludePatterns
+        .filter(p => typeof p === 'string' && p.trim())
+        .map(p => `${p.trim()}/pyproject.toml`);
+    const ignorePatterns = [...resolveWorkspaceDiscoveryIgnore(opts), ...DEFAULT_UV_DISCOVERY_IGNORE];
+    const globOpts = {
+        cwd: root,
+        absolute: true,
+        onlyFiles: true,
+        ignore: [...ignorePatterns, ...excludeGlobs],
+        followSymbolicLinks: false,
+    };
+    const patterns = toManifestGlobPatterns(memberPatterns.filter(p => typeof p === 'string'), 'pyproject.toml');
+    const manifestPaths = await fg(patterns, globOpts);
+    if (!manifestPaths.includes(rootPyproject) && hasProjectMetadata(parsed)) {
+        manifestPaths.unshift(rootPyproject);
+    }
+    return filterManifestPathsByDiscoveryIgnore(manifestPaths, root, ignorePatterns);
+}
+/**
+ * @param {import('smol-toml').TomlTable} parsedPyProject
+ * @returns {boolean}
+ */
+function hasProjectMetadata(parsedPyProject) {
+    try {
+        return typeof parsedPyProject?.project?.name === 'string' && parsedPyProject.project.name.trim() !== '';
+    }
+    catch {
+        return false;
+    }
+}