@dbx-tools/projen 0.6.77 → 0.6.79

package/README.md

@@ -260,6 +260,19 @@ a new package is covered without a re-synth. Work from the root:
 | `bun run barrels` | regenerate the read-only `index.ts` barrels        |
 | `bun run bump`    | version, tag, and publish                          |
 
+`bump` also mirrors a release into local registries when the active clients are
+pointed at loopback services. npm uses `npm config get registry` and publishes
+to a local Verdaccio automatically. Python prefers uv's default index and only
+treats a loopback `.../+simple/` URL as writable devpi; a read-only cache such as
+proxpi (`.../index/`) is deliberately ignored. The task stamps every Python
+member and its sibling dependencies to the release version, builds the workspace
+with uv, then runs `devpi upload --from-dir` against the derived writable index.
+Devpi client authentication remains in its normal `~/.devpi` state.
+
+Use `--local-registry false` or `--local-pypi false` to disable either local
+publish. An explicit `--local-pypi http://localhost:3141/user/index/` overrides
+auto-detection; `--python-root` defaults to `packages/py`.
+
 Members intentionally keep only the tasks that something OTHER than a human
 invokes, so there is no second place to run the same thing:
 

package/index.ts

@@ -36,11 +36,11 @@ export { repoRoot, DEFAULT_PACKAGE_ROOTS, DiscoveredPackage } from "./src/packag
 export type { RecordedPackage } from "./src/packages.ts";
 export { PnpmWorkspaceState } from "./src/pnpm-workspace.ts";
 export type { Catalog, AllowBuilds, DBXToolsPNPMWorkspaceOptions } from "./src/pnpm-workspace.ts";
-export type { ApplyToProjectsOptions } from "./src/project.ts";
+export type { DBXToolsProjectLanguage, DBXToolsProjectOptions, DBXToolsProject, ApplyToProjectsOptions } from "./src/project.ts";
 export { PackageIdentifier, PROJEN_VERSION, DBXToolsNodeProject, ROOT_INSTALL_ONLY_MIXIN, DBXToolsTypeScriptProject } from "./src/project-js.ts";
-export type { DBXToolsProject, DBXToolsProjectOptions, DBXToolsTypeScriptProjectOptions } from "./src/project-js.ts";
-export { DBXToolsPythonWorkspace } from "./src/project-py.ts";
-export type { PythonRepositoryOptions, PythonPackageOptions, PythonReleaseOptions, DBXToolsPythonWorkspaceOptions } from "./src/project-py.ts";
+export type { DBXToolsJavaScriptProject, DBXToolsJavaScriptProjectOptions, DBXToolsTypeScriptProjectOptions } from "./src/project-js.ts";
+export { DBXToolsPythonProject, DBXToolsPythonWorkspace } from "./src/project-py.ts";
+export type { PythonRepositoryOptions, PythonPackageOptions, DBXToolsPythonProjectOptions, PythonReleaseOptions, DBXToolsPythonWorkspaceOptions } from "./src/project-py.ts";
 export { COMPILED_DIR, COMPILED_COMPILER_OPTIONS } from "./src/publish.ts";
 export { DBXToolsRelease } from "./src/release.ts";
 export type { StandaloneRelease, DBXToolsReleaseOptions } from "./src/release.ts";

package/package.json

@@ -26,9 +26,9 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.7.0",
-    "@dbx-tools/core": "0.6.77",
-    "@dbx-tools/path": "0.6.77",
-    "@dbx-tools/shared-core": "0.6.77",
+    "@dbx-tools/core": "0.6.79",
+    "@dbx-tools/path": "0.6.79",
+    "@dbx-tools/shared-core": "0.6.79",
     "commander": "^15.0.0",
     "concurrently": "^10.0.3",
     "constructs": "^10.6.0",
@@ -47,7 +47,7 @@
   },
   "main": "index.ts",
   "license": "Apache-2.0",
-  "version": "0.6.77",
+  "version": "0.6.79",
   "types": "index.ts",
   "type": "module",
   "exports": {

package/src/pnpm-workspace.ts

@@ -250,6 +250,7 @@ export class PnpmWorkspaceState {
    */
   public resolveMembers(project: Project, extraMembers: readonly string[] = []): void {
     const members = project.subprojects
+      .filter((sub): sub is javascript.NodeProject => sub instanceof javascript.NodeProject)
       .map((sub) => toPosix(relative(project.outdir, sub.outdir)))
       .filter(Boolean);
     // `extraMembers` are workspace siblings NOT attached as subprojects (e.g. the

package/src/project-js.ts

@@ -1,10 +1,10 @@
 /**
  * The dbx-tools project surface plus package tooling: the single
- * {@link DBXToolsProject} interface, the projen Node/TypeScript project classes,
+ * {@link DBXToolsJavaScriptProject} interface, the projen Node/TypeScript project classes,
  * naming, guards, manifest fields, and the shared root init.
  *
  * {@link DBXToolsNodeProject} (monorepo root) and {@link DBXToolsTypeScriptProject}
- * (a package, or a standalone compiling root) both implement {@link DBXToolsProject}.
+ * (a package, or a standalone compiling root) both implement {@link DBXToolsJavaScriptProject}.
  */
 import { existsSync, readdirSync } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
@@ -41,13 +41,14 @@ import { DBXToolsRelease, type StandaloneRelease } from "./release.ts";
 import { AGNOSTIC_COMPILER_OPTIONS, PACKAGE_TAG_MIXINS, type PackageTag } from "./tags.ts";
 import { DBXToolsRootTsconfig } from "./tsconfig.ts";
 import { DBXToolsVsCode } from "./vscode.ts";
+import type { DBXToolsProject, DBXToolsProjectOptions as CommonProjectOptions } from "./project.ts";
 
 /**
  * The dbx-tools project surface, backed by projen's Node toolchain. A single
  * interface for both the monorepo root and each package: it carries the
  * `dbxToolsConfig` component plus the npm-naming and root-only file components.
  */
-export interface DBXToolsProject extends javascript.NodeProject {
+export interface DBXToolsJavaScriptProject extends DBXToolsProject, javascript.NodeProject {
   /** The package's `dbxToolsConfig` component (tags + `package.json` config). */
   readonly dbxToolsConfig: DBXToolsConfig;
   /** npm scope (the `@scope` in `@scope/pkg`), without the leading `@`. */
@@ -342,7 +343,9 @@ export const PROJEN_VERSION = "^0.101.16";
  * inherits the root's config rather than emitting its own. `name`/`defaultReleaseBranch`
  * are resolved/applied by the caller.
  */
-function defaultProjectOptions(options: DBXToolsProjectOptions): DBXToolsProjectOptions {
+function defaultProjectOptions(
+  options: DBXToolsJavaScriptProjectOptions,
+): DBXToolsJavaScriptProjectOptions {
   const isRoot = options.parent === undefined;
   return {
     // Bun owns install/run/build/test locally and in CI. projen renders
@@ -420,7 +423,7 @@ function defaultProjectOptions(options: DBXToolsProjectOptions): DBXToolsProject
  * pristine array to seed a child's fresh one. Spread AFTER `...options`.
  */
 function copiedGitIgnoreOptions(
-  options: DBXToolsProjectOptions,
+  options: DBXToolsJavaScriptProjectOptions,
 ): Pick<javascript.NodeProjectOptions, "gitIgnoreOptions"> {
   if (!options.gitIgnoreOptions?.ignorePatterns) return {};
   return {
@@ -460,8 +463,9 @@ function defaultTypeScriptProjectOptions(
 const DEV_DEPS_ROOT: string[] = ["typescript@^5.9.3", "@types/bun@^1.3.14"];
 
 /** Options for {@link DBXToolsNodeProject} (the monorepo root). */
-export interface DBXToolsProjectOptions
+export interface DBXToolsJavaScriptProjectOptions
   extends
+    CommonProjectOptions,
     Partial<javascript.NodeProjectOptions>,
     DBXToolsConfigOptions,
     DBXToolsPNPMWorkspaceOptions {
@@ -529,7 +533,7 @@ export interface DBXToolsProjectOptions
 
 /** Options for {@link DBXToolsTypeScriptProject} (a package, or a compiling root). */
 export interface DBXToolsTypeScriptProjectOptions
-  extends Partial<typescript.TypeScriptProjectOptions>, DBXToolsProjectOptions {
+  extends Partial<typescript.TypeScriptProjectOptions>, DBXToolsJavaScriptProjectOptions {
   /** Emit the projen-owned bun app scaffolding (`bunfig.toml`/`dev.ts`/`build.ts`). */
   readonly bunApp?: boolean;
 }
@@ -539,7 +543,11 @@ export interface DBXToolsTypeScriptProjectOptions
  * {@link DBXToolsTypeScriptProject} per `src`-bearing folder, then emits the
  * shared config, tasks, `pnpm-workspace.yaml`, and barrels-on-synth.
  */
-export class DBXToolsNodeProject extends javascript.NodeProject implements DBXToolsProject {
+export class DBXToolsNodeProject
+  extends javascript.NodeProject
+  implements DBXToolsJavaScriptProject
+{
+  readonly language = "javascript" as const;
   readonly scope: string;
   readonly dbxToolsConfig: DBXToolsConfig;
   pnpmWorkspace?: PnpmWorkspaceState;
@@ -548,7 +556,7 @@ export class DBXToolsNodeProject extends javascript.NodeProject implements DBXTo
   private readonly extraWorkspaceMembers: readonly string[];
   private readonly rootInstallOnly: boolean;
 
-  constructor(options: DBXToolsProjectOptions = {}) {
+  constructor(options: DBXToolsJavaScriptProjectOptions = {}) {
     const { name, scope } = resolveIdentity(options);
     const releaseDefaults =
       options.release && options.releaseTrigger === undefined
@@ -622,8 +630,9 @@ export const ROOT_INSTALL_ONLY_MIXIN = mixin.create(
  */
 export class DBXToolsTypeScriptProject
   extends typescript.TypeScriptProject
-  implements DBXToolsProject
+  implements DBXToolsJavaScriptProject
 {
+  readonly language = "javascript" as const;
   readonly scope: string;
   readonly dbxToolsConfig: DBXToolsConfig;
   pnpmWorkspace?: PnpmWorkspaceState;
@@ -816,7 +825,7 @@ class PrettierIgnoreGenerated extends Component {
 /** Default leading path segment stripped from a package's name (not its tag). */
 const DEFAULT_OMIT_RELATIVE_PREFIX = ["node"];
 
-/** Normalize the {@link DBXToolsProjectOptions.omitRelativePrefix} option to a slug list. */
+/** Normalize the {@link DBXToolsJavaScriptProjectOptions.omitRelativePrefix} option to a slug list. */
 function resolveOmitRelativePrefix(option: OneOrMany<string> | undefined): string[] {
   const raw = option === undefined ? DEFAULT_OMIT_RELATIVE_PREFIX : option;
   const list = Array.isArray(raw) ? raw : [raw];
@@ -943,7 +952,7 @@ export function taskScript(_project: javascript.NodeProject, script: string, arg
  */
 function initProject(
   project: DBXToolsNodeProject | DBXToolsTypeScriptProject,
-  options: DBXToolsProjectOptions,
+  options: DBXToolsJavaScriptProjectOptions,
 ): void {
   // projen's GithubProject seeds a `# replace this` SampleReadme on every
   // project. READMEs are hand-written and owned outside projen, so drop the
@@ -1101,7 +1110,7 @@ function initProject(
 
   // Already-attached subprojects, keyed by repo-relative member path.
   const rootAbs = resolve(project.outdir);
-  const existing = new Map<string, DBXToolsProject>();
+  const existing = new Map<string, DBXToolsJavaScriptProject>();
   for (const sub of project.subprojects) {
     if (sub instanceof DBXToolsNodeProject || sub instanceof DBXToolsTypeScriptProject) {
       existing.set(toPosix(relative(rootAbs, sub.outdir)), sub);
@@ -1182,7 +1191,7 @@ class ChildGitignore extends IgnoreFile {
  */
 function swapChildGitignore(
   project: javascript.NodeProject,
-  options: DBXToolsProjectOptions,
+  options: DBXToolsJavaScriptProjectOptions,
 ): void {
   project.tryRemoveFile(".gitignore");
   const fresh = new ChildGitignore(project, ".gitignore", {

package/src/project-predicate.ts

@@ -11,7 +11,8 @@ import { IConstruct } from "constructs";
 import { Project } from "projen";
 import { project } from "..";
 import { toPosix } from "./packages.ts";
-import { DBXToolsProject, DBXToolsNodeProject, DBXToolsTypeScriptProject } from "./project-js.ts";
+import type { DBXToolsProject } from "./project.ts";
+import type { DBXToolsJavaScriptProject } from "./project-js.ts";
 
 /**
  * Guard: the construct is a projen {@link Project} - the base every builder here
@@ -27,11 +28,19 @@ export function isProject(): Predicate<IConstruct, Project> {
   return predicate.create((c: IConstruct): c is Project => Project.isProject(c));
 }
 
-/** Guard: the construct is a {@link DBXToolsProject} (a DBXTools Node or TypeScript project). */
+/** Guard: the construct implements the language-agnostic {@link DBXToolsProject} contract. */
 export function isDBXToolsProject(): Predicate<IConstruct, DBXToolsProject> {
   return isProject().and(
     (project): project is DBXToolsProject =>
-      project instanceof DBXToolsNodeProject || project instanceof DBXToolsTypeScriptProject,
+      (project as Partial<DBXToolsProject>).language === "javascript" ||
+      (project as Partial<DBXToolsProject>).language === "python",
+  );
+}
+
+/** Guard: the construct is a dbx-tools JavaScript/TypeScript project. */
+export function isDBXToolsJavaScriptProject(): Predicate<IConstruct, DBXToolsJavaScriptProject> {
+  return isDBXToolsProject().and(
+    (project): project is DBXToolsJavaScriptProject => project.language === "javascript",
   );
 }
 
@@ -97,14 +106,16 @@ export function hasIdentifierScope(
 
 /**
  * Matches DBXTools packages carrying every listed tag (`dbxToolsConfig.tags`), narrowing
- * {@link Project} to {@link DBXToolsProject} (tags live only on DBXTools packages). Also the
+ * {@link Project} to {@link DBXToolsJavaScriptProject} (tags live only on JavaScript packages). Also the
  * guard backing each built-in {@link PACKAGE_TAG_MIXINS} entry. Keep it in the SAME `.and(...)`
  * as any name/path filter (or last when chaining) - a later non-tag `.and` re-widens to
  * {@link Project} and drops the narrowing.
  */
-export function hasTag(...tags: OneOrMany<PathMatchInput>): Predicate<IConstruct, DBXToolsProject> {
+export function hasTag(
+  ...tags: OneOrMany<PathMatchInput>
+): Predicate<IConstruct, DBXToolsJavaScriptProject> {
   const matchers = projectMatchers(...tags);
-  return isDBXToolsProject().and((project) =>
+  return isDBXToolsJavaScriptProject().and((project) =>
     matchers.every((matcher) => project.dbxToolsConfig.tags.some((tag) => matcher(tag))),
   );
 }

package/src/project-py.ts

@@ -1,8 +1,9 @@
 /** Reusable uv workspace generation for Python packages hosted in a projen tree. */
 import { string } from "@dbx-tools/shared-core";
-import { Component, TextFile, type Project, javascript, vscode } from "projen";
+import { Component, type Project, javascript, python, vscode } from "projen";
 import { GithubWorkflow } from "projen/lib/github";
 import { JobPermission } from "projen/lib/github/workflows-model";
+import type { DBXToolsProject, DBXToolsProjectOptions } from "./project.ts";
 
 /** Git location used by direct `#subdirectory=` package dependencies. */
 export interface PythonRepositoryOptions {
@@ -12,7 +13,7 @@ export interface PythonRepositoryOptions {
 }
 
 /** One independently installable Python package in the uv workspace. */
-export interface PythonPackageOptions {
+export interface PythonPackageOptions extends DBXToolsProjectOptions {
   readonly directory: string;
   readonly name: string;
   readonly module: string;
@@ -20,10 +21,19 @@ export interface PythonPackageOptions {
   readonly dependencies?: readonly string[];
 }
 
+/** Options for one projen-native Python workspace member. */
+export interface DBXToolsPythonProjectOptions extends DBXToolsProjectOptions {
+  readonly parent: Project;
+  readonly package: PythonPackageOptions;
+  readonly repository: Required<PythonRepositoryOptions>;
+  readonly requiresPython: string;
+}
+
 /** Python release workflow configuration. */
 export interface PythonReleaseOptions {
   readonly workflowName?: string;
-  readonly environment?: string;
+  /** GitHub environment by Python distribution name. Defaults to `pypi-<name>`. */
+  readonly environments?: Readonly<Record<string, string>>;
   readonly environmentUrl?: string;
 }
 
@@ -69,27 +79,112 @@ function projectVscode(project: Project): vscode.VsCode | undefined {
   return (project as Project & { readonly vscode?: vscode.VsCode }).vscode;
 }
 
+/** A Python package implemented with projen's `PythonProject` and uv backend. */
+export class DBXToolsPythonProject extends python.PythonProject implements DBXToolsProject {
+  readonly language = "python" as const;
+  readonly packageOptions: PythonPackageOptions;
+  readonly uv: python.Uv;
+
+  constructor(options: DBXToolsPythonProjectOptions) {
+    const pkg = options.package;
+    super({
+      parent: options.parent,
+      outdir: pythonPackagePath(options.repository, pkg.directory),
+      name: pkg.name,
+      moduleName: pkg.module,
+      authorName: "",
+      authorEmail: "",
+      version: "0.0.0",
+      description: pkg.description,
+      github: false,
+      sample: false,
+      pytest: false,
+      projenrcPython: false,
+      projenrcJs: false,
+      projenrcTs: false,
+      pip: false,
+      venv: false,
+      setuptools: false,
+      poetry: false,
+      uv: true,
+      projenCommand: options.parent.projenCommand,
+      uvOptions: {
+        project: {
+          name: pkg.name,
+          version: "0.0.0",
+          description: pkg.description,
+          readme: "README.md",
+          requiresPython: options.requiresPython,
+          dependencies: [...(pkg.dependencies ?? [])],
+          urls: {
+            Source: `${options.repository.url.replace(/\.git$/, "")}/tree/${options.repository.ref}/${pythonPackagePath(options.repository, pkg.directory)}`,
+          },
+        },
+        buildSystem: {
+          requires: ["uv_build>=0.11.28,<0.12.0"],
+          buildBackend: "uv_build",
+        },
+        uv: {
+          buildBackend: {
+            moduleName: pkg.module,
+            moduleRoot: "src",
+            namespace: true,
+          },
+        },
+      },
+    });
+    this.packageOptions = pkg;
+    if (!(this.packagingManager instanceof python.Uv)) {
+      throw new Error(`Expected uv packaging for ${pkg.name}`);
+    }
+    this.uv = this.packagingManager;
+    this.uv.file.addDeletionOverride("project.authors");
+    this.uv.file.addDeletionOverride("dependency-groups");
+    this.uv.file.readonly = true;
+
+    for (const path of [".gitattributes", ".gitignore"]) {
+      this.tryRemoveFile(path);
+    }
+  }
+
+  /** The root workspace owns dependency installation for every member. */
+  public override postSynthesize(): void {}
+}
+
 /**
- * Generates a root uv workspace, member package metadata, Python tasks, editor
- * interpreter selection, and an optional trusted-publishing workflow.
+ * Generates a root uv workspace, projen-native Python member projects, Python
+ * tasks, editor interpreter selection, and an optional publishing workflow.
  */
 export class DBXToolsPythonWorkspace extends Component {
-  readonly packages: readonly PythonPackageOptions[];
+  readonly packages: readonly DBXToolsPythonProject[];
   readonly repository: Required<PythonRepositoryOptions>;
   readonly requiresPython: string;
+  readonly file: python.PyprojectTomlFile;
 
   constructor(project: javascript.NodeProject, options: DBXToolsPythonWorkspaceOptions) {
     super(project);
-    this.packages = options.packages;
     this.repository = {
       url: options.repository.url,
       ref: options.repository.ref ?? "main",
       root: options.repository.root ?? "packages/py",
     };
     this.requiresPython = options.requiresPython ?? ">=3.10";
-
-    this.emitWorkspace(project, options);
-    this.emitPackages(project);
+    this.file = this.emitWorkspace(project, options);
+    this.packages = options.packages.map(
+      (pkg) =>
+        new DBXToolsPythonProject({
+          parent: project,
+          package: pkg,
+          repository: this.repository,
+          requiresPython: this.requiresPython,
+        }),
+    );
+    for (const pkg of this.packages) {
+      const pyproject = `/${pythonPackagePath(this.repository, pkg.packageOptions.directory)}/pyproject.toml`;
+      project.gitignore.include(pyproject);
+      project.gitattributes.addAttributes(pyproject, "linguist-generated");
+      project.prettier?.addIgnorePattern(pyproject.slice(1));
+    }
     this.addTasks(project, options);
 
     const interpreterPath = options.interpreterPath ?? "${workspaceFolder}/.venv/bin/python";
@@ -115,81 +210,45 @@ export class DBXToolsPythonWorkspace extends Component {
   private emitWorkspace(
     project: javascript.NodeProject,
     options: DBXToolsPythonWorkspaceOptions,
-  ): void {
-    const devDependencies = options.devDependencies ?? DEFAULT_DEV_DEPENDENCIES;
+  ): python.PyprojectTomlFile {
     const testPaths = options.testPaths ?? [this.repository.root];
-    const ruffTarget = options.ruffTarget ?? "py310";
     const perFileIgnores = options.ruffPerFileIgnores ?? {};
-    new TextFile(project, "pyproject.toml", {
-      marker: false,
-      readonly: true,
-      lines: [
-        '# ~~ Generated by projen. To modify, edit .projenrc.ts and run "bunx projen".',
-        "[project]",
-        `name = ${quote(options.workspaceName ?? `${string.toSlug(project.name)}-python-workspace`)}`,
-        'version = "0.0.0"',
-        `requires-python = ${quote(this.requiresPython)}`,
-        "dependencies = []",
-        "",
-        "[dependency-groups]",
-        `dev = [${devDependencies.map(quote).join(", ")}]`,
-        "",
-        "[tool.uv]",
-        "package = false",
-        "",
-        "[tool.uv.workspace]",
-        `members = [${quote(`${this.repository.root}/*`)}]`,
-        "",
-        "[tool.uv.sources]",
-        ...this.packages.map((pkg) => `${pkg.name} = { workspace = true }`),
-        "",
-        "[tool.pytest.ini_options]",
-        'asyncio_mode = "auto"',
-        `testpaths = [${testPaths.map(quote).join(", ")}]`,
-        "",
-        "[tool.ruff]",
-        `target-version = ${quote(ruffTarget)}`,
-        "line-length = 100",
-        "",
-        "[tool.ruff.lint.per-file-ignores]",
-        ...Object.entries(perFileIgnores).map(
-          ([path, rules]) => `${quote(path)} = [${rules.map(quote).join(", ")}]`,
-        ),
-        "",
-      ],
+    const file = new python.PyprojectTomlFile(project, {
+      project: {
+        name: options.workspaceName ?? `${string.toSlug(project.name)}-python-workspace`,
+        version: "0.0.0",
+        requiresPython: this.requiresPython,
+        dependencies: [],
+      },
+      dependencyGroups: {
+        dev: [...(options.devDependencies ?? DEFAULT_DEV_DEPENDENCIES)],
+      },
+      tool: {
+        uv: python.uvConfig.toJson_UvConfiguration({
+          package: false,
+          workspace: { members: [`${this.repository.root}/*`] },
+        }),
+        pytest: {
+          ini_options: {
+            asyncio_mode: "auto",
+            testpaths: testPaths,
+          },
+        },
+        ruff: {
+          "target-version": options.ruffTarget ?? "py310",
+          "line-length": 100,
+          lint: {
+            "per-file-ignores": perFileIgnores,
+          },
+        },
+      },
     });
-  }
-
-  private emitPackages(project: javascript.NodeProject): void {
-    for (const pkg of this.packages) {
-      new TextFile(project, `${this.packagePath(pkg.directory)}/pyproject.toml`, {
-        marker: false,
-        readonly: true,
-        lines: [
-          '# ~~ Generated by projen. To modify, edit .projenrc.ts and run "bunx projen".',
-          "[project]",
-          `name = ${quote(pkg.name)}`,
-          'version = "0.0.0"',
-          `description = ${quote(pkg.description)}`,
-          'readme = "README.md"',
-          `requires-python = ${quote(this.requiresPython)}`,
-          `dependencies = [${(pkg.dependencies ?? []).map(quote).join(", ")}]`,
-          "",
-          "[project.urls]",
-          `Source = ${quote(`${this.repository.url.replace(/\.git$/, "")}/tree/${this.repository.ref}/${this.packagePath(pkg.directory)}`)}`,
-          "",
-          "[build-system]",
-          'requires = ["uv_build>=0.11.28,<0.12.0"]',
-          'build-backend = "uv_build"',
-          "",
-          "[tool.uv.build-backend]",
-          `module-name = ${quote(pkg.module)}`,
-          'module-root = "src"',
-          "namespace = true",
-          "",
-        ],
-      });
-    }
+    file.addOverride(
+      "tool.uv.sources",
+      Object.fromEntries(options.packages.map((pkg) => [pkg.name, { workspace: true }])),
+    );
+    file.readonly = true;
+    return file;
   }
 
   private addTasks(project: javascript.NodeProject, options: DBXToolsPythonWorkspaceOptions): void {
@@ -247,12 +306,20 @@ export class DBXToolsPythonWorkspace extends Component {
           env: { VERSION: "${{ inputs.version }}" },
           run: this.renderVersionStampScript(),
         },
-        { name: "Build distributions", run: "uv build --all-packages" },
+        {
+          name: "Build distributions",
+          run: this.packages
+            .map(
+              (pkg) =>
+                `uv build --package ${pkg.packageOptions.name} --out-dir dist/${pkg.packageOptions.directory}`,
+            )
+            .join("\n"),
+        },
         {
           name: "Validate distributions",
           run: [
-            `test "$(find dist -maxdepth 1 -type f | wc -l | tr -d ' ')" -eq ${this.packages.length * 2}`,
-            "uvx twine check dist/*",
+            `test "$(find dist -type f \\( -name '*.whl' -o -name '*.tar.gz' \\) | wc -l | tr -d ' ')" -eq ${this.packages.length * 2}`,
+            "uvx twine check dist/*/*.whl dist/*/*.tar.gz",
           ].join("\n"),
         },
         {
@@ -262,29 +329,34 @@ export class DBXToolsPythonWorkspace extends Component {
         },
       ],
     });
-    workflow.addJob("publish", {
-      if: "${{ inputs.publish }}",
-      needs: ["build"],
-      environment: {
-        name: options.environment ?? "pypi",
-        url: options.environmentUrl ?? "https://pypi.org/",
-      },
-      runsOn: ["ubuntu-latest"],
-      permissions: { idToken: JobPermission.WRITE },
-      timeoutMinutes: 10,
-      steps: [
-        {
-          name: "Download distributions",
-          uses: "actions/download-artifact@v8",
-          with: { name: "python-distributions", path: "dist" },
-        },
-        {
-          name: "Publish to PyPI",
-          uses: "pypa/gh-action-pypi-publish@release/v1",
-          with: { "packages-dir": "dist" },
+    for (const pkg of this.packages) {
+      workflow.addJob(`publish-${pkg.packageOptions.directory}`, {
+        if: "${{ inputs.publish }}",
+        needs: ["build"],
+        environment: {
+          name:
+            options.environments?.[pkg.packageOptions.name] ?? `pypi-${pkg.packageOptions.name}`,
+          url:
+            options.environmentUrl ??
+            `https://pypi.org/project/${pkg.packageOptions.name.replaceAll("_", "-")}/`,
         },
-      ],
-    });
+        runsOn: ["ubuntu-latest"],
+        permissions: { idToken: JobPermission.WRITE },
+        timeoutMinutes: 10,
+        steps: [
+          {
+            name: "Download distributions",
+            uses: "actions/download-artifact@v8",
+            with: { name: "python-distributions", path: "dist" },
+          },
+          {
+            name: `Publish ${pkg.packageOptions.name} to PyPI`,
+            uses: "pypa/gh-action-pypi-publish@release/v1",
+            with: { "packages-dir": `dist/${pkg.packageOptions.directory}` },
+          },
+        ],
+      });
+    }
   }
 
   private renderVersionStampScript(): string {

package/src/project.ts

@@ -5,14 +5,27 @@
 import { type PathMatchInput } from "@dbx-tools/path";
 import { object, type OneOrMany } from "@dbx-tools/shared-core";
 import { type IConstruct } from "constructs";
-import { Project } from "projen";
+import { Project, type ProjectOptions } from "projen";
 import * as mixin from "./mixin.ts";
 import * as projectPredicate from "./project-predicate.ts";
-import type { DBXToolsProject } from "./project-js.ts";
+import type { DBXToolsJavaScriptProject } from "./project-js.ts";
 
 export * from "./project-js.ts";
 export * from "./project-py.ts";
 
+/** Runtime family implemented by a dbx-tools project. */
+export type DBXToolsProjectLanguage = "javascript" | "python";
+
+/** Options shared by every dbx-tools project implementation. */
+export interface DBXToolsProjectOptions extends Partial<
+  Pick<ProjectOptions, "name" | "parent" | "outdir">
+> {}
+
+/** Minimal language-agnostic project contract. */
+export interface DBXToolsProject extends Project {
+  readonly language: DBXToolsProjectLanguage;
+}
+
 /** Filters selecting which projects an {@link applyToProjects} call runs against. */
 export interface ApplyToProjectsOptions {
   /** Include plain projen projects. Defaults to DBXTools projects only. */
@@ -45,8 +58,8 @@ type ApplyToAllProjectsOptions = Omit<ApplyToProjectsOptions, "includeNonDBXTool
 export function applyToProjects(
   construct: IConstruct,
   ...args:
-    | [ApplyToDBXToolsProjectsOptions, ...OneOrMany<(project: DBXToolsProject) => void>]
-    | OneOrMany<(project: DBXToolsProject) => void>
+    | [ApplyToDBXToolsProjectsOptions, ...OneOrMany<(project: DBXToolsJavaScriptProject) => void>]
+    | OneOrMany<(project: DBXToolsJavaScriptProject) => void>
 ): void;
 
 export function applyToProjects(
@@ -71,7 +84,7 @@ export function applyToProjects<P extends Project>(
   const callbacks = (hasOptions ? rest : args) as OneOrMany<(project: Project) => void>;
   let predicate = projectPredicate.isProject();
   if (!options?.includeNonDBXToolsProjects) {
-    predicate = predicate.and(projectPredicate.isDBXToolsProject());
+    predicate = predicate.and(projectPredicate.isDBXToolsJavaScriptProject());
   }
   if (!options?.includeRoots) predicate = predicate.and((project) => project.parent != null);
   if (options?.identifierPackageName) {

package/src/publish.ts

@@ -29,7 +29,7 @@
  */
 import type { javascript } from "projen";
 import { typescript } from "projen";
-import { isDBXToolsProject } from "./project-predicate.ts";
+import { isDBXToolsJavaScriptProject } from "./project-predicate.ts";
 import { addPackageFiles, applyCompilerOptions, applyIncludes } from "./project.ts";
 
 /** Directory `tsc` emits into, and the root of every published entry point. */
@@ -63,7 +63,7 @@ export const COMPILED_COMPILER_OPTIONS: javascript.TypeScriptCompilerOptions = {
  */
 export function publishesCompiled(pkg: javascript.NodeProject): boolean {
   if (!(pkg instanceof typescript.TypeScriptProject) || !pkg.parent) return false;
-  return isDBXToolsProject()(pkg) && !pkg.dbxToolsConfig.tags.includes("ui");
+  return isDBXToolsJavaScriptProject()(pkg) && !pkg.dbxToolsConfig.tags.includes("ui");
 }
 
 /** The `./lib/...` stem of a source path, or `undefined` if it is not TypeScript. */

package/tasks/bump.ts

@@ -30,12 +30,11 @@
  * `--publish` / `--no-publish` is an alias for `--push` (pushing the tag is
  * what publishes). The tag prefix comes from `--prefix` (default `v`).
  *
- * `--local-registry <value>` publishes the just-tagged version to a LOCAL
- * registry (e.g. a verdaccio) right after the git tag is pushed - so a local
- * `bun run bump` both fires the GitHub release (public npm) and populates your
- * local registry. Values:
+ * `--local-registry <value>` publishes npm packages to a LOCAL registry (e.g.
+ * verdaccio) right after the tag push. `--local-pypi <value>` does the same for
+ * Python packages through a writable devpi index. Values for both:
  *   - `auto` (default): publish only when `npm config get registry` is a
- *     loopback host (`localhost` / `127.0.0.0/8` / `::1`); otherwise skip.
+ *     loopback host, or uv's default index is a loopback devpi `+simple` URL.
  *   - `false`: never publish locally.
  *   - a URL: always publish to that registry.
  */
@@ -45,6 +44,7 @@ import { fileURLToPath } from "node:url";
 import { exec, project } from "@dbx-tools/core";
 import { log, net } from "@dbx-tools/shared-core";
 import { Command, Option } from "commander";
+import { activePythonIndex, resolveLocalPypi } from "./python-registry.ts";
 
 const logger = log.logger("projen:bump");
 const LEVELS = ["patch", "minor", "major"] as const;
@@ -188,6 +188,12 @@ program
     "publish locally after the tag push: 'auto' (only a loopback npm registry), 'false', or a registry URL",
     "auto",
   )
+  .option(
+    "--local-pypi <value>",
+    "publish Python packages locally: 'auto' (only a loopback devpi +simple index), 'false', or a devpi URL",
+    "auto",
+  )
+  .option("--python-root <path>", "Python workspace package root", "packages/py")
   .action(
     (opts: {
       level: Level;
@@ -199,7 +205,9 @@ program
       tag: boolean;
       push: boolean;
       publish: boolean;
+      localPypi: string;
       localRegistry: string;
+      pythonRoot: string;
     }) => {
       const pkgPath = resolve(process.cwd(), "package.json");
       if (!existsSync(pkgPath)) throw new Error(`no package.json in ${process.cwd()}`);
@@ -314,6 +322,45 @@ program
         logger.success(`published ${version} to ${localRegistry}`);
       }
 
+      const activeIndex = activePythonIndex();
+      const localPypi = resolveLocalPypi(opts.localPypi, activeIndex);
+      const pythonRoot = resolve(opts.pythonRoot);
+      if (
+        opts.localPypi.toLowerCase() === "auto" &&
+        activeIndex &&
+        net.isLoopbackHost(new URL(activeIndex)) &&
+        !localPypi
+      ) {
+        logger.info(`skipped local Python publish: ${activeIndex} is not a devpi +simple index`);
+      }
+      if (opts.version === false && localPypi) {
+        logger.info("skipped local Python publish (--no-version left packages unstamped)");
+      } else if (opts.version && localPypi && existsSync(pythonRoot)) {
+        logger.info(`publishing Python ${version} to local devpi ${localPypi.publishUrl}`);
+        const publishPythonScript = fileURLToPath(new URL("./publish-python.ts", import.meta.url));
+        exec.spawnSync(
+          "bun",
+          [
+            publishPythonScript,
+            version,
+            "--root",
+            pythonRoot,
+            "--index-url",
+            localPypi.indexUrl,
+            "--publish-url",
+            localPypi.publishUrl,
+          ],
+          {
+            cwd: process.cwd(),
+            stdout: "inherit",
+            stderr: "inherit",
+            stdin: "ignore",
+            check: true,
+          },
+        );
+        logger.success(`published Python ${version} to ${localPypi.publishUrl}`);
+      }
+
       // Publishing can run package lifecycle hooks, including a standalone
       // project's own projen synth, which rewrites its generated manifest back
       // to 0.0.0. Re-assert the release version last so root and every sibling

package/tasks/publish-python.ts

@@ -0,0 +1,146 @@
+#!/usr/bin/env -S bun
+import {
+  chmodSync,
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, join, resolve } from "node:path";
+import { exec } from "@dbx-tools/core";
+import { Command } from "commander";
+
+interface PythonProjectFile {
+  readonly directory: string;
+  readonly mode: number;
+  readonly name: string;
+  readonly path: string;
+  readonly source: string;
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export function stampPythonProjects(root: string, version: string): () => void {
+  const packageFiles = readdirSync(root, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => resolve(root, entry.name, "pyproject.toml"))
+    .filter(existsSync)
+    .sort();
+  const projects: PythonProjectFile[] = packageFiles.map((path) => {
+    const source = readFileSync(path, "utf8");
+    const name = /^name = "([^"]+)"$/m.exec(source)?.[1];
+    if (!name) throw new Error(`Missing project name in ${path}`);
+    return {
+      directory: basename(resolve(path, "..")),
+      mode: statSync(path).mode,
+      name,
+      path,
+      source,
+    };
+  });
+  if (projects.length === 0) throw new Error(`No Python packages found under ${root}`);
+
+  try {
+    for (const project of projects) {
+      let stamped = project.source.replace(/^version = "[^"]+"$/m, `version = "${version}"`);
+      if (stamped === project.source) {
+        throw new Error(`Expected one project version in ${project.path}`);
+      }
+      for (const sibling of projects) {
+        stamped = stamped.replace(
+          new RegExp(
+            `${escapeRegExp(sibling.name)} @ git\\+[^" ]+#subdirectory=[^" ]+/${escapeRegExp(sibling.directory)}`,
+            "g",
+          ),
+          `${sibling.name}==${version}`,
+        );
+      }
+      chmodSync(project.path, project.mode | 0o200);
+      writeFileSync(project.path, stamped);
+    }
+  } catch (error) {
+    for (const project of projects) {
+      chmodSync(project.path, project.mode | 0o200);
+      writeFileSync(project.path, project.source);
+      chmodSync(project.path, project.mode);
+    }
+    throw error;
+  }
+
+  return () => {
+    for (const project of projects) {
+      chmodSync(project.path, project.mode | 0o200);
+      writeFileSync(project.path, project.source);
+      chmodSync(project.path, project.mode);
+    }
+  };
+}
+
+export function publishPythonProjects(options: {
+  readonly dryRun?: boolean;
+  readonly indexUrl: string;
+  readonly publishUrl: string;
+  readonly root: string;
+  readonly version: string;
+}): void {
+  const root = resolve(options.root);
+  const output = mkdtempSync(join(tmpdir(), "dbx-tools-python-publish-"));
+  const restore = stampPythonProjects(root, options.version);
+  try {
+    exec.spawnSync("uv", ["build", "--all-packages", "--out-dir", output], {
+      cwd: process.cwd(),
+      stdout: "inherit",
+      stderr: "inherit",
+      stdin: "ignore",
+      check: true,
+    });
+    exec.spawnSync(
+      "uvx",
+      [
+        "--from",
+        "devpi-client",
+        "devpi",
+        "upload",
+        "--index",
+        options.publishUrl,
+        "--from-dir",
+        ...(options.dryRun ? ["--dry-run"] : []),
+        output,
+      ],
+      {
+        cwd: process.cwd(),
+        env: { ...process.env, UV_DEFAULT_INDEX: options.indexUrl },
+        stdout: "inherit",
+        stderr: "inherit",
+        stdin: "ignore",
+        check: true,
+      },
+    );
+  } finally {
+    restore();
+    rmSync(output, { recursive: true, force: true });
+  }
+}
+
+if (import.meta.main) {
+  const program = new Command();
+  program
+    .argument("<version>", "Python package version")
+    .requiredOption("--index-url <url>", "devpi Simple API URL")
+    .requiredOption("--publish-url <url>", "devpi writable index URL")
+    .option("--root <path>", "Python workspace package root", "packages/py")
+    .option("--dry-run", "build and inspect distributions without uploading")
+    .action(
+      (
+        version: string,
+        options: { dryRun?: boolean; indexUrl: string; publishUrl: string; root: string },
+      ) => publishPythonProjects({ ...options, version }),
+    );
+  await program.parseAsync();
+}

package/tasks/python-registry.ts

@@ -0,0 +1,87 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+import { exec } from "@dbx-tools/core";
+import { net } from "@dbx-tools/shared-core";
+
+export interface LocalPythonRegistry {
+  readonly indexUrl: string;
+  readonly publishUrl: string;
+}
+
+/** Read the default index URL from uv's TOML configuration. */
+export function parseUvDefaultIndex(source: string): string | undefined {
+  const blocks = source.split(/(?=^\[\[index\]\]\s*$)/m);
+  for (const block of blocks) {
+    if (!/^\[\[index\]\]\s*$/m.test(block) || !/^\s*default\s*=\s*true\s*$/m.test(block)) {
+      continue;
+    }
+    const url = /^\s*url\s*=\s*["']([^"']+)["']\s*$/m.exec(block)?.[1];
+    if (url) return url;
+  }
+  return undefined;
+}
+
+/** Convert a devpi Simple API URL into its writable index URL. */
+export function devpiRegistry(index: string): LocalPythonRegistry | undefined {
+  let url: URL;
+  try {
+    url = new URL(index);
+  } catch {
+    return undefined;
+  }
+  if (!net.isLoopbackHost(url)) return undefined;
+
+  const path = url.pathname.replace(/\/+$/, "");
+  if (!path.endsWith("/+simple")) return undefined;
+  url.pathname = `${path.slice(0, -"/+simple".length)}/`;
+  url.search = "";
+  url.hash = "";
+  return {
+    indexUrl: new URL("+simple/", url).href,
+    publishUrl: url.href,
+  };
+}
+
+/** The active Python package index, preferring uv because Python builds use uv. */
+export function activePythonIndex(): string | undefined {
+  for (const value of [process.env.UV_DEFAULT_INDEX, process.env.UV_INDEX_URL]) {
+    if (value?.trim()) return value.trim();
+  }
+
+  const uvConfig = process.env.UV_CONFIG_FILE ?? resolve(homedir(), ".config/uv/uv.toml");
+  if (existsSync(uvConfig)) {
+    const index = parseUvDefaultIndex(readFileSync(uvConfig, "utf8"));
+    if (index) return index;
+  }
+
+  if (process.env.PIP_INDEX_URL?.trim()) return process.env.PIP_INDEX_URL.trim();
+  const pip = exec.spawnSync("python", ["-m", "pip", "config", "get", "global.index-url"], {
+    cwd: process.cwd(),
+    stdout: "capture",
+    stderr: "ignore",
+    stdin: "ignore",
+    check: false,
+  });
+  return pip.stdout?.trim() || undefined;
+}
+
+/** Resolve `auto`, `false`, or an explicit devpi index/publish URL. */
+export function resolveLocalPypi(
+  value: string,
+  activeIndex: string | undefined = activePythonIndex(),
+): LocalPythonRegistry | undefined {
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.toLowerCase() === "false") return undefined;
+  if (trimmed.toLowerCase() === "auto") {
+    return activeIndex ? devpiRegistry(activeIndex) : undefined;
+  }
+
+  const derived = devpiRegistry(trimmed);
+  if (derived) return derived;
+  const publishUrl = trimmed.endsWith("/") ? trimmed : `${trimmed}/`;
+  return {
+    publishUrl,
+    indexUrl: new URL("+simple/", publishUrl).href,
+  };
+}