@mnci/nx-python-pip 0.1.1

package/dist/internal/pythonProject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pythonProject.d.ts","sourceRoot":"","sources":["../../src/internal/pythonProject.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,mBAAmB,CAAE,IAAI,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,MAAM,CAkBlF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAE,eAAe,EAAE,MAAM,GAAG,MAAM,CAInE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAE,eAAe,EAAE,MAAM,GAAG,MAAM,CAOjE"}

package/dist/internal/pythonProject.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pythonModuleDirectory = pythonModuleDirectory;
+exports.pythonPyprojectToml = pythonPyprojectToml;
+exports.pythonSampleModule = pythonSampleModule;
+exports.pythonSampleTest = pythonSampleTest;
+/**
+ * A Python project's module directory name, derived from its Nx project name.
+ *
+ * @remarks
+ * Python identifiers cannot contain hyphens, so `my-svc` becomes `my_svc`.
+ *
+ * @param name - The Nx project name.
+ * @returns The module directory's basename (e.g. `my_svc`).
+ * @throws Never - pure string mapping.
+ * @typeParam None - this function has no generic type parameters.
+ */
+function pythonModuleDirectory(name) {
+    return name.replaceAll('-', '_');
+}
+/**
+ * The `pyproject.toml` written for a buildable Python project (app or lib).
+ *
+ * @remarks
+ * `hatchling` is the PEP 517 backend. The wheel target's `packages` list is
+ * explicit (not hatchling's own auto-detection) because the `build` executor
+ * patches this exact list when vendoring an internal-lib's module into the
+ * wheel (see `parseVendorEntries`). `dependencies` starts empty — external
+ * and vendored dependencies alike are wired by hand after generation; no
+ * generator wires cross-project Python dependencies automatically.
+ *
+ * @param name - The project name.
+ * @param moduleDirectory - The project's module directory basename.
+ * @returns The `pyproject.toml` contents.
+ * @throws Never - pure string build.
+ * @typeParam None - this function has no generic type parameters.
+ */
+function pythonPyprojectToml(name, moduleDirectory) {
+    return `[project]
+name = "${name}"
+version = "1.0.0"
+description = ""
+requires-python = ">=3.9"
+dependencies = []
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["${moduleDirectory}"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+`;
+}
+/**
+ * A sample pure function written into a generated Python project's module.
+ *
+ * @remarks
+ * Gives every generated project a genuinely testable unit out of the box —
+ * paired with {@link pythonSampleTest}.
+ *
+ * @param moduleDirectory - The project's module directory basename.
+ * @returns The `<module>/__init__.py` contents.
+ * @throws Never - pure string build.
+ * @typeParam None - this function has no generic type parameters.
+ */
+function pythonSampleModule(moduleDirectory) {
+    return `def hello() -> str:
+    return "hello from ${moduleDirectory}"
+`;
+}
+/**
+ * The sample pytest proving a generated Python project's `test` target runs.
+ *
+ * @remarks
+ * Imports {@link pythonSampleModule}'s function, so a fresh project's `test`
+ * target is green out of the box, no wiring needed.
+ *
+ * @param moduleDirectory - The project's module directory basename.
+ * @returns The `tests/test_<module>.py` contents.
+ * @throws Never - pure string build.
+ * @typeParam None - this function has no generic type parameters.
+ */
+function pythonSampleTest(moduleDirectory) {
+    return `from ${moduleDirectory} import hello
+
+
+def test_hello() -> None:
+    assert hello() == "hello from ${moduleDirectory}"
+`;
+}
+//# sourceMappingURL=pythonProject.js.map

package/dist/internal/pythonProject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pythonProject.js","sourceRoot":"","sources":["../../src/internal/pythonProject.ts"],"names":[],"mappings":";;;;;;AAAA;;;;;;;;;;GAUG;AACH,+BAAuC,IAAY;IACjD,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;AAClC,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,6BAAqC,IAAY,EAAE,eAAuB;IACxE,OAAO;UACC,IAAI;;;;;;;;;;;eAWC,eAAe;;;;CAI7B,CAAA;AACD,CAAC;AAED;;;;;;;;;;;GAWG;AACH,4BAAoC,eAAuB;IACzD,OAAO;yBACgB,eAAe;CACvC,CAAA;AACD,CAAC;AAED;;;;;;;;;;;GAWG;AACH,0BAAkC,eAAuB;IACvD,OAAO,QAAQ,eAAe;;;;oCAII,eAAe;CAClD,CAAA;AACD,CAAC"}

package/dist/internal/vendor.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Extracts the vendored internal-lib project names from a `pyproject.toml`'s
+ * `[tool.mnci-python-pip] vendor = [...]` table.
+ *
+ * @remarks
+ * Plain pip has no bundled-local-dependency feature (the pip-world
+ * equivalent of `@nxlv/python`'s `bundleLocalDependencies`), so a project
+ * that imports a workspace-internal Python library needs this hand-added
+ * entry — the pip-world counterpart of hand-wiring a `dependencies = [...]`
+ * entry. This package wires no cross-project Python dependency
+ * automatically, for vendoring or otherwise.
+ *
+ * Parsed with a regex, not a TOML library: this package authors the exact
+ * shape of the table it looks for (`generateBuildableProject` never writes
+ * this table itself — it is always hand-added after generation), so a
+ * regex is sufficient and avoids a TOML dependency for one line.
+ *
+ * @param pyprojectToml - The `pyproject.toml` file contents.
+ * @returns The vendored project names (e.g. `["pycore"]`), or `[]` when the
+ * project vendors nothing.
+ * @throws Never - a missing/malformed table simply yields an empty array.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export declare function parseVendorEntries(pyprojectToml: string): string[];
+/**
+ * Appends module directory names to a `pyproject.toml`'s
+ * `[tool.hatch.build.targets.wheel] packages` list.
+ *
+ * @remarks
+ * `generateBuildableProject` always writes this list with just the project's
+ * own module; a staged build (see the `build` executor) patches it here to
+ * also include each vendored module, so hatchling packages them as real
+ * top-level packages in the wheel.
+ *
+ * @param pyprojectToml - The staged `pyproject.toml` file contents.
+ * @param moduleDirectories - The vendored modules' directory names to add.
+ * @returns The patched `pyproject.toml` contents.
+ * @throws Never - when no `packages` list is found, the content is returned unchanged.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export declare function addPackagesToWheelTarget(pyprojectToml: string, moduleDirectories: string[]): string;
+//# sourceMappingURL=vendor.d.ts.map

package/dist/internal/vendor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vendor.d.ts","sourceRoot":"","sources":["../../src/internal/vendor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,kBAAkB,CAAE,aAAa,EAAE,MAAM,GAAG,MAAM,EAAE,CASnE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,wBAAwB,CAAE,aAAa,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,EAAE,GAAG,MAAM,CASpG"}

package/dist/internal/vendor.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVendorEntries = parseVendorEntries;
+exports.addPackagesToWheelTarget = addPackagesToWheelTarget;
+/**
+ * Extracts the vendored internal-lib project names from a `pyproject.toml`'s
+ * `[tool.mnci-python-pip] vendor = [...]` table.
+ *
+ * @remarks
+ * Plain pip has no bundled-local-dependency feature (the pip-world
+ * equivalent of `@nxlv/python`'s `bundleLocalDependencies`), so a project
+ * that imports a workspace-internal Python library needs this hand-added
+ * entry — the pip-world counterpart of hand-wiring a `dependencies = [...]`
+ * entry. This package wires no cross-project Python dependency
+ * automatically, for vendoring or otherwise.
+ *
+ * Parsed with a regex, not a TOML library: this package authors the exact
+ * shape of the table it looks for (`generateBuildableProject` never writes
+ * this table itself — it is always hand-added after generation), so a
+ * regex is sufficient and avoids a TOML dependency for one line.
+ *
+ * @param pyprojectToml - The `pyproject.toml` file contents.
+ * @returns The vendored project names (e.g. `["pycore"]`), or `[]` when the
+ * project vendors nothing.
+ * @throws Never - a missing/malformed table simply yields an empty array.
+ * @typeParam None - this function has no generic type parameters.
+ */
+function parseVendorEntries(pyprojectToml) {
+    const match = /^\s*vendor\s*=\s*\[([^\]]*)\]/m.exec(pyprojectToml);
+    if (!match) {
+        return [];
+    }
+    return match[1]
+        .split(',')
+        .map((entry) => entry.trim().replaceAll(/^["']|["']$/g, ''))
+        .filter(Boolean);
+}
+/**
+ * Appends module directory names to a `pyproject.toml`'s
+ * `[tool.hatch.build.targets.wheel] packages` list.
+ *
+ * @remarks
+ * `generateBuildableProject` always writes this list with just the project's
+ * own module; a staged build (see the `build` executor) patches it here to
+ * also include each vendored module, so hatchling packages them as real
+ * top-level packages in the wheel.
+ *
+ * @param pyprojectToml - The staged `pyproject.toml` file contents.
+ * @param moduleDirectories - The vendored modules' directory names to add.
+ * @returns The patched `pyproject.toml` contents.
+ * @throws Never - when no `packages` list is found, the content is returned unchanged.
+ * @typeParam None - this function has no generic type parameters.
+ */
+function addPackagesToWheelTarget(pyprojectToml, moduleDirectories) {
+    return pyprojectToml.replace(/^(\s*packages\s*=\s*)\[([^\]]*)\]/m, (_match, prefix, existing) => {
+        const names = existing
+            .split(',')
+            .map((entry) => entry.trim().replaceAll(/^["']|["']$/g, ''))
+            .filter(Boolean);
+        const merged = [...new Set([...names, ...moduleDirectories])];
+        return `${prefix}[${merged.map((name) => `"${name}"`).join(', ')}]`;
+    });
+}
+//# sourceMappingURL=vendor.js.map

package/dist/internal/vendor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vendor.js","sourceRoot":"","sources":["../../src/internal/vendor.ts"],"names":[],"mappings":";;;;AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,4BAAoC,aAAqB;IACvD,MAAM,KAAK,GAAG,gCAAgC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAA;IAClE,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,OAAO,EAAE,CAAA;IACX,CAAC;IACD,OAAO,KAAK,CAAC,CAAC,CAAC;SACZ,KAAK,CAAC,GAAG,CAAC;SACV,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,UAAU,CAAC,cAAc,EAAE,EAAE,CAAC,CAAC;SAC3D,MAAM,CAAC,OAAO,CAAC,CAAA;AACpB,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,kCAA0C,aAAqB,EAAE,iBAA2B;IAC1F,OAAO,aAAa,CAAC,OAAO,CAAC,oCAAoC,EAAE,CAAC,MAAM,EAAE,MAAc,EAAE,QAAgB,EAAE,EAAE;QAC9G,MAAM,KAAK,GAAG,QAAQ;aACnB,KAAK,CAAC,GAAG,CAAC;aACV,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,UAAU,CAAC,cAAc,EAAE,EAAE,CAAC,CAAC;aAC3D,MAAM,CAAC,OAAO,CAAC,CAAA;QAClB,MAAM,MAAM,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,KAAK,EAAE,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAAA;QAC7D,OAAO,GAAG,MAAM,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAA;IACrE,CAAC,CAAC,CAAA;AACJ,CAAC"}

package/dist/release/versionActions.d.ts

@@ -0,0 +1,107 @@
+import type { ProjectGraph, Tree } from '@nx/devkit';
+declare const VersionActions: typeof import("nx/release").VersionActions;
+/**
+ * Hand-written Nx release `VersionActions` for pip-native Python packages
+ * (no uv, no Poetry) — reads/writes the `version = "..."` line under
+ * `pyproject.toml`'s `[project]` table.
+ *
+ * @remarks
+ * Registered per-project via `library` generator's
+ * `release.version.versionActions: '@mnci/nx-python-pip/release/version-actions'`
+ * (see `generateProject.ts`), which wins over whatever default the
+ * consuming workspace's `nx.json` configures. Verified empirically against a
+ * real `nx release version --dry-run` (both the disk-fallback and
+ * git-tag-based resolution paths).
+ *
+ * The `version = "..."` line is read/written with a regex, not a TOML
+ * library: this package authors `pyproject.toml`'s exact shape itself (via
+ * `pythonPyprojectToml`), so a regex on the one line that changes is safe
+ * and avoids a TOML dependency for it.
+ *
+ * @typeParam None - this class has no generic type parameters.
+ */
+export default class PythonVersionActions extends VersionActions {
+    validManifestFilenames: string[];
+    /**
+     * Reads the current version from `pyproject.toml`'s `[project]` table.
+     *
+     * @param tree - The Nx virtual file system.
+     * @returns The current version and the manifest path, or `null` when the
+     * manifest does not exist.
+     * @throws Error when the manifest exists but has no `version = "..."` line.
+     * @typeParam None - this method has no generic type parameters.
+     */
+    readCurrentVersionFromSourceManifest(tree: Tree): Promise<{
+        currentVersion: string;
+        manifestPath: string;
+    } | null>;
+    /**
+     * Resolves the current published version via `pip index versions`.
+     *
+     * @remarks
+     * `pip index` is an experimental pip command (stable enough for this
+     * lookup); a package that has never been published, or a registry with no
+     * matching entry, is not an error here — it just means there is no
+     * registry-known current version yet, so `null` is returned instead of
+     * throwing (mirrors how a brand-new npm package behaves under the
+     * `registry` current-version resolver).
+     *
+     * @param _tree - Unused (the registry, not the workspace, is the source here).
+     * @param _currentVersionResolverMetadata - Unused (no registry-specific metadata needed).
+     * @returns The current published version (or `null`) and a log message.
+     * @throws Never - a lookup failure yields `null`, not a throw.
+     * @typeParam None - this method has no generic type parameters.
+     */
+    readCurrentVersionFromRegistry(_tree: Tree, _currentVersionResolverMetadata: Record<string, unknown> | undefined): Promise<{
+        currentVersion: string | null;
+        logText: string;
+    } | null>;
+    /**
+     * Resolves the current version of a dependency of this project.
+     *
+     * @remarks
+     * Internal-lib dependencies are vendored (copied into the wheel at build
+     * time by the `build` executor), not registry-referenced, so there is no
+     * separate version to track — the same branch `@nxlv/python`'s own
+     * reference implementation took for bundled dependencies.
+     *
+     * @param _tree - Unused.
+     * @param _projectGraph - Unused.
+     * @param _dependencyProjectName - Unused.
+     * @returns `null` for both fields — nothing to report.
+     * @throws Never - pure no-op.
+     * @typeParam None - this method has no generic type parameters.
+     */
+    readCurrentVersionOfDependency(_tree: Tree, _projectGraph: ProjectGraph, _dependencyProjectName: string): Promise<{
+        currentVersion: string | null;
+        dependencyCollection: string | null;
+    }>;
+    /**
+     * Writes the newly computed version into `pyproject.toml`.
+     *
+     * @param tree - The Nx virtual file system.
+     * @param newVersion - The new version to write.
+     * @returns A one-line log message describing the change.
+     * @throws Never - propagates only if the manifest genuinely cannot be read
+     * (would already have thrown in `readCurrentVersionFromSourceManifest`).
+     * @typeParam None - this method has no generic type parameters.
+     */
+    updateProjectVersion(tree: Tree, newVersion: string): Promise<string[]>;
+    /**
+     * Updates dependency versions in this project's manifest.
+     *
+     * @remarks
+     * Same reasoning as {@link readCurrentVersionOfDependency}: dependencies
+     * are vendored, not registry references, so there is nothing to update.
+     *
+     * @param _tree - Unused.
+     * @param _projectGraph - Unused.
+     * @param _dependenciesToUpdate - Unused.
+     * @returns An empty array — no log messages, nothing changed.
+     * @throws Never - pure no-op.
+     * @typeParam None - this method has no generic type parameters.
+     */
+    updateProjectDependencies(_tree: Tree, _projectGraph: ProjectGraph, _dependenciesToUpdate: Record<string, string>): Promise<string[]>;
+}
+export {};
+//# sourceMappingURL=versionActions.d.ts.map

package/dist/release/versionActions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"versionActions.d.ts","sourceRoot":"","sources":["../../src/release/versionActions.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAEpD,QAAA,MAAQ,cAAc,4CAAyD,CAAA;AAI/E;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,OAAO,OAAO,oBAAqB,SAAQ,cAAc;IAC9D,sBAAsB,WAAqB;IAE3C;;;;;;;;OAQG;IACG,oCAAoC,CAAE,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC;QAAE,cAAc,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC,CAWxH;IAED;;;;;;;;;;;;;;;;OAgBG;IACG,8BAA8B,CAClC,KAAK,EAAE,IAAI,EACX,+BAA+B,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GACnE,OAAO,CAAC;QAAE,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC,CASpE;IAED;;;;;;;;;;;;;;;OAeG;IACG,8BAA8B,CAClC,KAAK,EAAE,IAAI,EACX,aAAa,EAAE,YAAY,EAC3B,sBAAsB,EAAE,MAAM,GAC7B,OAAO,CAAC;QAAE,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC,CAEjF;IAED;;;;;;;;;OASG;IACG,oBAAoB,CAAE,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAK7E;IAED;;;;;;;;;;;;;OAaG;IACG,yBAAyB,CAC7B,KAAK,EAAE,IAAI,EACX,aAAa,EAAE,YAAY,EAC3B,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC5C,OAAO,CAAC,MAAM,EAAE,CAAC,CAEnB;CACF"}

package/dist/release/versionActions.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = require("node:path");
+// eslint-disable-next-line @typescript-eslint/no-require-imports -- nx/release is CJS; no ESM entry to `import` from.
+const { VersionActions } = require('nx/release');
+const VERSION_LINE = /^version\s*=\s*"([^"]+)"/m;
+/**
+ * Hand-written Nx release `VersionActions` for pip-native Python packages
+ * (no uv, no Poetry) — reads/writes the `version = "..."` line under
+ * `pyproject.toml`'s `[project]` table.
+ *
+ * @remarks
+ * Registered per-project via `library` generator's
+ * `release.version.versionActions: '@mnci/nx-python-pip/release/version-actions'`
+ * (see `generateProject.ts`), which wins over whatever default the
+ * consuming workspace's `nx.json` configures. Verified empirically against a
+ * real `nx release version --dry-run` (both the disk-fallback and
+ * git-tag-based resolution paths).
+ *
+ * The `version = "..."` line is read/written with a regex, not a TOML
+ * library: this package authors `pyproject.toml`'s exact shape itself (via
+ * `pythonPyprojectToml`), so a regex on the one line that changes is safe
+ * and avoids a TOML dependency for it.
+ *
+ * @typeParam None - this class has no generic type parameters.
+ */
+class PythonVersionActions extends VersionActions {
+    constructor() {
+        super(...arguments);
+        this.validManifestFilenames = ['pyproject.toml'];
+    }
+    /**
+     * Reads the current version from `pyproject.toml`'s `[project]` table.
+     *
+     * @param tree - The Nx virtual file system.
+     * @returns The current version and the manifest path, or `null` when the
+     * manifest does not exist.
+     * @throws Error when the manifest exists but has no `version = "..."` line.
+     * @typeParam None - this method has no generic type parameters.
+     */
+    async readCurrentVersionFromSourceManifest(tree) {
+        const manifestPath = (0, node_path_1.join)(this.projectGraphNode.data.root, 'pyproject.toml');
+        const content = tree.read(manifestPath, 'utf8');
+        if (content === null) {
+            return null;
+        }
+        const match = VERSION_LINE.exec(content);
+        if (!match) {
+            throw new Error(`Could not find a "version = ..." line under [project] in ${manifestPath}`);
+        }
+        return { currentVersion: match[1], manifestPath };
+    }
+    /**
+     * Resolves the current published version via `pip index versions`.
+     *
+     * @remarks
+     * `pip index` is an experimental pip command (stable enough for this
+     * lookup); a package that has never been published, or a registry with no
+     * matching entry, is not an error here — it just means there is no
+     * registry-known current version yet, so `null` is returned instead of
+     * throwing (mirrors how a brand-new npm package behaves under the
+     * `registry` current-version resolver).
+     *
+     * @param _tree - Unused (the registry, not the workspace, is the source here).
+     * @param _currentVersionResolverMetadata - Unused (no registry-specific metadata needed).
+     * @returns The current published version (or `null`) and a log message.
+     * @throws Never - a lookup failure yields `null`, not a throw.
+     * @typeParam None - this method has no generic type parameters.
+     */
+    async readCurrentVersionFromRegistry(_tree, _currentVersionResolverMetadata) {
+        const name = this.projectGraphNode.name;
+        try {
+            const output = (0, node_child_process_1.execFileSync)('python3', ['-m', 'pip', 'index', 'versions', name], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+            const match = /Available versions:\s*([^\s,]+)/.exec(output);
+            return { currentVersion: match ? match[1] : null, logText: 'from pip index versions' };
+        }
+        catch {
+            return { currentVersion: null, logText: 'package not found on registry' };
+        }
+    }
+    /**
+     * Resolves the current version of a dependency of this project.
+     *
+     * @remarks
+     * Internal-lib dependencies are vendored (copied into the wheel at build
+     * time by the `build` executor), not registry-referenced, so there is no
+     * separate version to track — the same branch `@nxlv/python`'s own
+     * reference implementation took for bundled dependencies.
+     *
+     * @param _tree - Unused.
+     * @param _projectGraph - Unused.
+     * @param _dependencyProjectName - Unused.
+     * @returns `null` for both fields — nothing to report.
+     * @throws Never - pure no-op.
+     * @typeParam None - this method has no generic type parameters.
+     */
+    async readCurrentVersionOfDependency(_tree, _projectGraph, _dependencyProjectName) {
+        return { currentVersion: null, dependencyCollection: null };
+    }
+    /**
+     * Writes the newly computed version into `pyproject.toml`.
+     *
+     * @param tree - The Nx virtual file system.
+     * @param newVersion - The new version to write.
+     * @returns A one-line log message describing the change.
+     * @throws Never - propagates only if the manifest genuinely cannot be read
+     * (would already have thrown in `readCurrentVersionFromSourceManifest`).
+     * @typeParam None - this method has no generic type parameters.
+     */
+    async updateProjectVersion(tree, newVersion) {
+        const manifestPath = (0, node_path_1.join)(this.projectGraphNode.data.root, 'pyproject.toml');
+        const content = tree.read(manifestPath, 'utf8') ?? '';
+        tree.write(manifestPath, content.replace(VERSION_LINE, () => `version = "${newVersion}"`));
+        return [`Updated ${manifestPath} to version ${newVersion}`];
+    }
+    /**
+     * Updates dependency versions in this project's manifest.
+     *
+     * @remarks
+     * Same reasoning as {@link readCurrentVersionOfDependency}: dependencies
+     * are vendored, not registry references, so there is nothing to update.
+     *
+     * @param _tree - Unused.
+     * @param _projectGraph - Unused.
+     * @param _dependenciesToUpdate - Unused.
+     * @returns An empty array — no log messages, nothing changed.
+     * @throws Never - pure no-op.
+     * @typeParam None - this method has no generic type parameters.
+     */
+    async updateProjectDependencies(_tree, _projectGraph, _dependenciesToUpdate) {
+        return [];
+    }
+}
+exports.default = PythonVersionActions;
+//# sourceMappingURL=versionActions.js.map

package/dist/release/versionActions.js.map

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

package/executors.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://json-schema.org/draft-07/schema",
+  "executors": {
+    "build": {
+      "implementation": "./dist/executors/build/executor",
+      "schema": "./dist/executors/build/schema.json",
+      "description": "Build a Python wheel/sdist with python -m build, vendoring internal libs declared via [tool.mnci-python-pip] vendor."
+    },
+    "test": {
+      "implementation": "./dist/executors/test/executor",
+      "schema": "./dist/executors/test/schema.json",
+      "description": "Run pytest, optionally installing the project in editable mode first."
+    },
+    "lint": {
+      "implementation": "./dist/executors/lint/executor",
+      "schema": "./dist/executors/lint/schema.json",
+      "description": "Run ruff check ."
+    },
+    "publish": {
+      "implementation": "./dist/executors/publish/executor",
+      "schema": "./dist/executors/publish/schema.json",
+      "description": "Publish a wheel/sdist with twine upload; honours nx release publish --dry-run."
+    }
+  }
+}

package/generators.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://json-schema.org/draft-07/schema",
+  "generators": {
+    "application": {
+      "factory": "./dist/generators/application/generator",
+      "schema": "./dist/generators/application/schema.json",
+      "description": "Create a pip-native Python application (pyproject.toml + project.json with lint/test/build targets)."
+    },
+    "library": {
+      "factory": "./dist/generators/library/generator",
+      "schema": "./dist/generators/library/schema.json",
+      "description": "Create a publishable pip-native Python library (adds a twine nx-release-publish target + a versionActions override)."
+    },
+    "internal-library": {
+      "factory": "./dist/generators/internalLibrary/generator",
+      "schema": "./dist/generators/internalLibrary/schema.json",
+      "description": "Create a private, never-published Python library (lint/test only)."
+    },
+    "function-application": {
+      "factory": "./dist/generators/functionApplication/generator",
+      "schema": "./dist/generators/functionApplication/schema.json",
+      "description": "Create a Python Azure Function app (v2 programming model), deployed as source, not a wheel."
+    }
+  }
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@mnci/nx-python-pip",
+  "version": "0.1.1",
+  "description": "An Nx plugin for pip-native Python projects (Ruff + pytest + the standard PyPA build/twine tools) — no uv, no Poetry, no lock file.",
+  "publishConfig": {
+    "access": "public"
+  },
+  "generators": "./generators.json",
+  "executors": "./executors.json",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./release/version-actions": {
+      "types": "./dist/release/versionActions.d.ts",
+      "default": "./dist/release/versionActions.js"
+    },
+    "./package.json": "./package.json",
+    "./generators.json": "./generators.json",
+    "./executors.json": "./executors.json"
+  },
+  "files": [
+    "dist",
+    "generators.json",
+    "executors.json"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.lib.json && node scripts/copySchemas.mjs",
+    "test": "jest",
+    "lint": "eslint ."
+  },
+  "keywords": [
+    "nx",
+    "nx-plugin",
+    "python",
+    "pip",
+    "azure-functions"
+  ],
+  "author": "Eduardo Russo",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/russoedu/MoNecromanCi.git",
+    "directory": "packages/nx-python-pip"
+  },
+  "peerDependencies": {
+    "@nx/devkit": ">=21.0.0",
+    "nx": ">=21.0.0"
+  },
+  "devDependencies": {
+    "@nx/devkit": "23.1.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^26.0.1",
+    "eslint": "^10.6.0",
+    "jest": "^30.4.2",
+    "nx": "23.1.0",
+    "ts-jest": "^29.4.11",
+    "typescript": "^6.0.3"
+  }
+}