@dbx-tools/projen 0.9.19 → 0.9.28

package/README.md

@@ -19,7 +19,7 @@ Key features:
   files based on package predicates.
 - OpenAPI client generation from tsoa controllers and zod schema generation from
   `.d.ts` inputs.
-- Read-only generated-file stamping, cleanup, and watch-loop helpers.
+- Read-only generated-file ownership, cleanup, and watch-loop helpers.
 
 ## Define A Workspace Root
 
@@ -45,8 +45,12 @@ instead of creating a second owner. An explicit `outdir` is the workspace root
 for naming, Git metadata, package discovery, codegen, and barrels even when the
 calling process has a different current directory.
 
-The unified dbx-tools release surface is enabled by default. Set
-`releaseMode: "disabled"` to omit its workflow and bump/version/release tasks.
+The unified dbx-tools release surface is enabled by default. `bump` increments
+the local `VERSION` and synchronizes generated version surfaces. `release`
+commits that bump on the configured release branch, pushes it, and pushes an
+annotated version tag. The generated GitHub workflow runs only for matching tag
+pushes and publishes directly from that immutable commit. Set
+`releaseMode: "disabled"` to omit the workflow and bump/version/release tasks.
 The inherited Projen `release` and `releaseTrigger` options are intentionally
 not part of this engine's public options because they create a competing release
 workflow.
@@ -58,13 +62,8 @@ Repository policy stays in the consuming `.projenrc.ts`:
   artifact upload, and deployment without naming a docs script or output tree.
 - `releasePythonRoot` passes the actual Python package root to local release
   preparation. Omit it when the workspace has no standard Python packages.
-- `releaseValidationTasks` names repository tasks that must pass in the release
-  worktree before Cargo tests, compilation, local publication, or approval.
-  Use it for repository-specific guards that also run in release CI.
-- `releaseSummary` controls versioned release notes. It defaults to Cursor,
-  Codex, Claude fallback order and writes a deterministic Git summary when every
-  configured provider is unavailable; pass `false` to disable or provide a
-  `providers` array to choose the order/subset.
+- `releaseValidationTasks` names repository tasks that must pass in tag CI
+  before release artifacts are built and published.
 - `pullRequestTitlePolicy` configures semantic title types and scope policy.
   Omit it or pass `false` to disable the title job.
 - `workflowCacheIgnorePaths` excludes generated output trees that may contain
@@ -90,8 +89,9 @@ without turning Python packages into JavaScript workspace projects. It generates
 the root and member `pyproject.toml` files, standard `py:*` tasks, the VS Code
 interpreter setting, and an optional manual PyPI trusted-publishing workflow.
 Projen's native `PyprojectTomlFile` owns generated TOML formatting. Temporary
-publication stamping uses parsed TOML, changes versions and sibling
-dependencies structurally, and restores the original files byte-for-byte.
+release packaging copies each project to an isolated directory and projects
+sibling registry requirements there with parsed TOML. Source manifests already
+carry the root `VERSION` and are never rewritten for publication.
 
 ```ts
 import { project, projectPy } from "@dbx-tools/projen";
@@ -123,193 +123,70 @@ without repeating repository coordinates. Pass `repository`, `name`, or
 VS Code component; dbx-tools reuses it rather than constructing a second
 `.vscode/settings.json` owner.
 
-## Add A Rust Workspace
-
-`DBXToolsRustWorkspace` discovers every source-bearing folder under its
-configurable `root` (default `packages/rs`), generates its Cargo manifest, and
-derives the crate name and repository from the parent project. A crate containing
-`uniffi::setup_scaffolding!()`
-automatically wires matching public Node and Python binding packages using the
-`<name>-rs` folder suffix. Node packages are named `@<scope>/<name>-rs`;
-Python distributions are named `<scope>-<name>-rs` and export generated values
-from `<scope>.<name>_rs`. Binding packages are always dedicated and
-never merge generated code into handwritten Node or Python packages.
-Repository-specific dependencies and features remain
-declarative options in `.projenrc.ts`; generated bindings are built separately
-from projen synthesis. Target-independent Node binding TypeScript is committed
-and remains generated/read-only, while native libraries stay ignored. Node
-facades compile to `lib/` and publish JavaScript entry points that plain Node
-can load from `node_modules`. A complete `bindings.ts` / `_bindings.ts` /
-`_bindings-ffi.ts` triplet is exported directly from the generated package
-barrel. Python keeps `bindings.py` as the generated implementation and leaves
-`__init__.py` as its generated package-root export. Node generation fails when
-direct binding names conflict.
-Do not create a `nodeExports` binding subpath or a handwritten type facade.
-
-Each discovered member is a native Projen `Project`, exposed as
-`DBXToolsRustProject`. The same class also owns standalone Cargo projects with
-the flat object-style options used by the Node and Python project classes:
+### Bundle Node Code For PythonMonkey
 
-```ts
-import { project } from "@dbx-tools/projen";
+Add `nodeBindings` to any `DBXToolsPythonWorkspace` package to generate a
+committed CommonJS runtime and async Python wrappers from a public Node package.
+The configuration is written to `pyproject.toml`, so the generation task also
+works in consuming repositories after `@dbx-tools/projen` is installed.
 
-new project.DBXToolsRustProject({
-  name: "my-apps-core",
-  outdir: "native/core",
-  version: "0.1.0",
-  description: "Shared native runtime",
-  repository: "https://github.com/example/my-apps",
+```ts
+new project.DBXToolsPythonWorkspace(root, {
+  root: "packages/py",
+  packages: [
+    {
+      directory: "auth",
+      description: "Python bindings for example auth",
+      nodeBindings: {
+        package: "@example/auth",
+        layout: "package",
+        private: false,
+        shimRoot: "projen/shims/python-node",
+        functionOverrides: [
+          {
+            module: "@example/core/file-lock",
+            export: "acquireFileLock",
+            handler: "projen/shims/python-node/file-lock.ts",
+          },
+        ],
+      },
+    },
+  ],
 });
 ```
 
-The project emits concrete standalone Cargo metadata plus `compile`, `test`,
-`package`, `lint`, `format`, and `format:check` tasks. A nested standalone
-project declares its own empty Cargo workspace so a surrounding repository
-workspace does not absorb it accidentally. The `examples` option emits explicit
-Cargo example targets and `required-features`, so an optional code generator is
-excluded from ordinary workspace tests until its feature is enabled.
-`DBXToolsRustWorkspace` constructs the same class with workspace-owned metadata
-and keeps aggregate binding and release coordination.
-`DBXToolsRustWorkspaceOptions.private` supplies the default Cargo publication
-policy for every discovered crate; a package-level `private` value overrides it.
-Cargo projects use the flat object-style constructor exclusively.
-
-Rust dependencies between binding-enabled workspace crates become Node
-`workspace:*` and Python `internalDependencies` automatically. Python generation
-selects the owning crate and supplies `external_packages` imports. UBRN currently
-emits every linked component; the generation task discards dependency outputs
-and rewrites their imports to the owning package root, including its generated
-`uniffiModule` converter table. It never copies a dependency's records or enums.
-Foreign callback adapters must first be wrapped in an object created by their
-own native library (`createStorageHandle` for auth), because callback registries
-are library-local. Release wheels replace sibling Git requirements with matching
-native-wheel versions, and dependent publishers wait for their dependencies.
-Each crate builds its own `<crate>-uniffi-bindgen` executable so one target row
-has no colliding binary outputs. The executable requires the generated
-`uniffi-bindgen` feature, which enables `uniffi/cli` only in the UniFFI matrix.
-Packaging runs that prebuilt executable.
-Cargo manifests, target config, and UniFFI config are generated from structured
-Projen `TomlFile` objects. Local and release Python generation share one
-dependency-free helper for generator arguments, target-specific executable
-names, generated headers, generated package-root exports, and native-library
-placement.
-
-`sync --watch` runs a focused Rust watcher beside the OpenAPI watcher. Changes
-inside an existing UniFFI crate regenerate that crate and its dependent bindings
-in dependency order; adding or
-removing a crate or `setup_scaffolding!()` marker triggers a full synth. Repos
-without Rust crates start no Rust watcher. When Rust projects are detected,
-Cargo is required and the focused task fails immediately if it is unavailable.
-`rs:bindings` is explicit rather than part of root `pre-compile`, so ordinary
-JavaScript PR builds type-check committed generated bindings without performing
-a host Rust build. Regenerate bindings through the focused watcher or explicit
-task while changing a UniFFI API. Release preparation runs Cargo workspace tests
-without invoking UBRN.
-
-Rust fingerprinting and binary version stamping use the dependency-free Node
-helper generated at `.projen/rust-release.mjs`. The implementation ships with
-`@dbx-tools/projen`, so consumers do not need a repository-specific helper
-crate, a crates.io publication, or an extra Cargo build before release
-orchestration can start.
-
-The workspace generates one `release.yml` workflow for every ecosystem. One
-root `VERSION` drives every Node, Python, Cargo, native, and GitHub artifact.
-`bun run release` prepares one reviewed PR into `main`; it enables automatic
-merge by default and accepts `--no-approve` for a human-controlled merge. One
-non-cancelling `release` concurrency group serializes publication.
-
-Release generation writes `release.yml` without scanning for or removing other
-workflow files. Consumers explicitly delete exact workflow files they no longer
-want.
-
-The release workflow accepts stage-specific manual recovery only for the exact
-annotated tag and expected SHA. npm retries compare archive content and
-repository identity, PyPI uses hash-aware existing-file behavior, Cargo checks
-existing versions, and GitHub assets upload to the single repository release.
-
-Set `releaseSyncBranch` when a repository retains a long-lived source branch.
-After publication the workflow fast-forwards a branch that is behind, skips a
-branch that already contains released `main`, and merges `main` into a diverged
-branch when the merge is conflict-free. Missing branches and conflicted merges
-are left untouched.
-
-Rust release generation creates one uncached matrix with one row per target.
-Each row builds all discovered bindings and selected release binaries together
-with the union of their required features, then packages every native artifact
-from that one Cargo output. Set a source-only crate's or release-enabled
-binary's `releaseExcludeOs` package option to omit it from incompatible rows.
-Release binary packaging and artifact upload are skipped in those rows. UniFFI
-crates cannot use this option because every configured target must produce
-their artifacts.
-Set a release binary's `cli` package option and the workspace
-`cliRegistryPath` to generate a typed `dbx` command registry from the same
-selected targets. The generated entries carry only the archives that the
-release matrix publishes, so an excluded operating system fails locally before
-any download is attempted. The runtime command uses `@dbx-tools/core`
-`bin.ensure`; the core installer itself contains no product registry.
-Rust rows prepare native npm
-archives and Python wheels; they do not install Bun or UBRN and do not build
-Node facades. A binary-only row therefore installs no language package tool.
-`rustVersion` remains the MSRV recorded in package manifests, while
-`releaseRustVersion` independently defaults release compilation to `stable`.
-Rows use the target runner's standard Rust toolchain without sccache, Cargo
-cache actions, source fingerprints, or reusable raw bundles. Phase timings are
-written to each build log. GitHub-hosted Python generation executes the
-already-built `target/<triple>/release/<crate>-uniffi-bindgen` directly. A local
-macOS build compiles one host generator and reuses it while packaging the
-Darwin, Linux, and Windows libraries.
-
-Artifacts identify their crate, target, and type. Rust jobs publish non-private
-Cargo crates with `cargo publish --no-verify` and upload requested binary assets
-to the GitHub release. Rust jobs never publish npm or PyPI packages.
-
-Set `LOCAL_CARGO_REGISTRY` to a named Cargo registry such as a loopback
-[Kellnr](https://kellnr.io/) instance and provide `LOCAL_CARGO_TOKEN`. Public
-Cargo crates also publish directly to crates.io
-with `CARGO_REGISTRY_TOKEN`. Override `releaseTargets` only when a consumer has
-additional native runners; ordinary projects inherit the maintained matrix
-automatically. `bun run release` also accepts repeatable `--os` and `--arch`
-selectors; every selected operating system is crossed with every selected
-architecture. Omit both filters to regenerate the complete maintained matrix.
-`DBX_TOOLS_RELEASE_PLATFORMS` can select the generated matrix without repeating
-environment parsing in a consumer.
-
-`bun run release` always prepares the production candidate locally. After the
-reviewed release pull request merges, the local process checks out the exact
-merge commit, builds the complete npm, Python, native binding, and Rust binary
-artifact set, then creates an annotated tag and draft GitHub Release. The draft
-contains `release-manifest.json`, `SHA256SUMS`, and every registry or binary
-artifact bound to that commit. A manager can rebuild an interrupted draft from
-the exact source with
-`bun run release:assets --version <version> --tag <tag> --sha <commit> --upload`.
-Publishing the draft is the production promotion event; `release.yml` verifies
-the tag, commit, version, manifest, checksums, and asset set before publishing
-the approved npm archives, Python distributions, and Cargo crates. GitHub-hosted
-runners never rebuild native release artifacts for singular-version releases.
-
-Public UniFFI facades are marked with `dbxToolsConfig.uniffi = true` in Node
-manifests and `[tool.dbx_tools.config] uniffi = true` in Python manifests. The
-approved npm archives are dependency-ordered and published through npm OIDC
-Trusted Publishing with provenance. Local Verdaccio publication does not enable
-provenance. Python publishes the exact approved wheels and source distributions
-through package-specific PyPI trusted-publisher environments; binding publishers
-wait for their dependencies. Trusted-publisher instructions name `release.yml`
-and the `v*` deployment tag policy. Cargo publication checks the approved source
-commit and skips an already-published version during recovery.
-The docs jobs generate README and TypeScript API content and deploy GitHub Pages
-from the same workflow. When a conventional Node binding path already belongs
-to a root subproject, Rust mapping reuses that project and adds binding
-dependencies and metadata to its existing manifest.
-
-The workspace npm publisher owns compilation for normal release publication. It
-selects every publishable package with compiled entry points, invokes one
-root-level filtered compile, then packs each package exactly once with lifecycle
-scripts disabled. It validates the archive identity, configured access,
-integrity, and repository metadata before publishing those same bytes. Local
-release preparation passes `--skip-compile` only after its immediately preceding
-validation compile and verifies every expected output exists before reuse.
-Package `prepack` tasks remain available for standalone publishes without
-multiplying `tsc --build` across the monorepo release flow.
+`layout: "package"` owns the complete Python package under `generated-src`.
+Use the default `layout: "submodule"` to place generated bindings under
+`<module>._generated` beside handwritten source. Generated wrappers convert
+public function names to `snake_case`, await promises, recursively convert plain
+records and arrays, and proxy returned JavaScript class instances with
+`snake_case` async methods.
+
+Set `private: true` to keep every generated symbol out of the generated
+`__init__.py`. The runtime and `node_bindings.py` remain available for a
+handwritten consuming package to import selectively. The default is `false`.
+
+Every function parameter is resolved through the TypeScript compiler API and
+rendered with its Python-equivalent name and type. Supported record types become
+keyword-only Python dataclasses, nested records become nested dataclasses, and a
+same-named exported companion's `defaults()` method supplies field defaults. A
+trailing optional record can be passed as the dataclass, a dictionary, or direct
+snake-case keyword fields. Generation fails with the property path when a type
+cannot be represented safely in Python.
+
+Return types use the same compiler model. Plain records become generated
+`TypedDict` responses, returned clients and class instances become `Protocol`
+types with typed async methods, and primitives, arrays, maps, promises, and
+optional values retain their corresponding Python annotations.
+
+The workspace creates `<name>:python-runtime`,
+`<name>:python-runtime:check`, and, for workspace Node dependencies,
+`<name>:python-runtime:watch`. The root sync watcher includes the watch task.
+Built-in shims can make ordinary Node imports work under PythonMonkey.
+`functionOverrides` replaces named exports only in the generated runtime, so the
+Node package does not gain Python callbacks or alternate source files. A
+replacement may use a different export name through `handlerExport`; every
+other export continues to come from the original module.
 
 ## Customize Packages With Mixins
 
@@ -469,10 +346,9 @@ file contract as the CLI.
 - `barrels` / `moduleExports` - public entrypoint generation.
 - `codegen` - `.d.ts` to zod schema generation.
 - `openapi` - tsoa/OpenAPI package generation.
-- `releaseCatalog` / `releasePlan` / `releasePlease` - cross-language ownership,
-  affected planning, and Release Please graph propagation.
+- `releaseCatalog` - cross-language package ownership and publication order.
 - `bunApp` / `tsconfig` / `vscode` - generated support files/components.
-- `generated` / `clean` / `watch` / `scaffold` - read-only file stamping,
+- `generated` / `clean` / `watch` / `scaffold` - read-only file ownership,
   cleanup, watchers, and synth orchestration.
 - `publish` - packaging and tag-based release helpers.
 - `engineRoot` - engine package root resolution for bootstrapped repos.
@@ -499,36 +375,15 @@ list, so 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`                 | increment `VERSION` and regenerate version surfaces  |
 | `bun run version:check`        | verify every generated version against `VERSION`     |
-| `bun run release`              | validate, open, and automatically merge a release PR |
-| `bun run release --no-approve` | open the release PR without automatic merge          |
-
-`release` commits and pushes pending source work, creates a release worktree,
-increments `VERSION`, synthesizes manifests and registries, runs validation and
-local publication, writes the release summary, and opens one PR. It enables
-automatic merge unless `--no-approve` is supplied. The merged `VERSION` change
-starts publication from the exact `main` SHA and creates one `v<version>` tag;
-the command waits for that workflow by default. Use `--no-wait` to return after
-requesting auto-merge, `--no-validate` to skip repository tests/compile, or
-`--no-local-publish` to skip local registry preflight.
-Version resolution considers both repository tags and historical
-`<component>-v<version>` tags, ensuring a singular release starts above every
-component version left by an independent-version migration.
-The repository host and owner are derived from the Git remote. If the GitHub CLI
-has multiple accounts for that host, release preparation selects the first
-authenticated account with write access to the detected repository. Classic
-tokens must include the `workflow` scope so the release PR can update the
-generated workflow.
-
-The GitHub PR workflow runs the explicit `pr:validate` task through Projen's
-public `BuildWorkflow` `buildTask` option. That task runs synth plus the
-workspace TypeScript compile rather than the complete root build. Release
-preparation has already run Rust tests, workspace type-checking, and local
-package preflight before opening the PR. JavaScript behavior tests remain an
-explicit developer task.
-
-The generated workflow publishes the complete public workspace at the singular
-version. Rust, Python, Node, GitHub asset, and docs stages share the verified tag
-and SHA. Documentation generation runs only on this version-triggered workflow.
+| `bun run release`              | run the configured release transaction                |
+
+Run exactly `bun run release` from a clean `main`. It calls the existing `bump`
+task, commits the generated version changes, pushes `main`, and pushes the
+matching annotated `vX.Y.Z` tag. Pass `--no-bump` only to release an existing
+synchronized local bump. The tag workflow verifies that the tag points at the
+exact `origin/main` commit, publishes npm and PyPI directly from that checkout,
+then builds and deploys documentation. Local npm and Python registry publication
+remains available through the direct local publication tooling.
 
 Members intentionally keep only the tasks that something OTHER than a human
 invokes, so there is no second place to run the same thing:
@@ -557,7 +412,6 @@ from the root instead.
 ## Versioning
 
 `VERSION` is the language-neutral version seam. Real package manifests remain
-Projen-owned and reproduce it exactly across JavaScript, Python, Rust, UniFFI
-bindings, native package metadata, and runtime binary registries. Package and
+Projen-owned and reproduce it exactly across JavaScript and Python packages. Package and
 artifact discovery still supplies publication order and target inventory; it
 does not create independent version ownership.

package/index.ts

@@ -3,7 +3,7 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export const PACKAGE_IDENTIFIER = "@dbx-tools/projen";
-export const PACKAGE_VERSION = "0.9.19";
+export const PACKAGE_VERSION = "0.9.28";
 export * as barrels from "./src/barrels.ts";
 export * as bunApp from "./src/bun-app.ts";
 export * as bunWorkflow from "./src/bun-workflow.ts";
@@ -21,19 +21,17 @@ export * as project from "./src/project.ts";
 export * as projectJs from "./src/project-js.ts";
 export * as projectPredicate from "./src/project-predicate.ts";
 export * as projectPy from "./src/project-py.ts";
-export * as projectRs from "./src/project-rs.ts";
 export * as projenVersion from "./src/projen-version.ts";
 export * as publish from "./src/publish.ts";
+export * as pythonNodeBindings from "./src/python-node-bindings.ts";
+export * as pythonNodeBundle from "./src/python-node-bundle.ts";
 export * as release from "./src/release.ts";
 export * as releaseCatalog from "./src/release-catalog.ts";
-export * as releaseDispatch from "./src/release-dispatch.ts";
+export * as releaseContext from "./src/release-context.ts";
 export * as releaseGithub from "./src/release-github.ts";
-export * as releasePlan from "./src/release-plan.ts";
-export * as releasePlease from "./src/release-please.ts";
 export * as scaffold from "./src/scaffold.ts";
 export * as tags from "./src/tags.ts";
 export * as tsconfig from "./src/tsconfig.ts";
-export * as uniffi from "./src/uniffi.ts";
 export * as vscode from "./src/vscode.ts";
 export * as watch from "./src/watch.ts";
 export * as workspaceLock from "./src/workspace-lock.ts";
@@ -46,7 +44,7 @@ export type { DBXToolsConfigOptions } from "./src/dbx-tools-config.ts";
 export { resolvePkgRoot } from "./src/engine-root.ts";
 export type { HeaderOpts } from "./src/generated.ts";
 export type { ConstructsMixin } from "./src/mixin.ts";
-export type { ModuleStatement, ModuleExport } from "./src/module-exports.ts";
+export type { ModuleStatement, ModuleExport, PublicFunctionExport } from "./src/module-exports.ts";
 export { repoRoot, DEFAULT_PACKAGE_ROOTS, DiscoveredPackage } from "./src/packages.ts";
 export type { RecordedPackage } from "./src/packages.ts";
 export { PnpmWorkspaceState } from "./src/pnpm-workspace.ts";
@@ -56,25 +54,20 @@ export { PackageIdentifier, DBX_TOOLS_LICENSE, DBXToolsNodeProject, ROOT_INSTALL
 export type { DBXToolsJavaScriptProject, DBXToolsReleaseMode, PullRequestTitlePolicyOptions, DBXToolsJavaScriptProjectOptions, DBXToolsTypeScriptProjectOptions } from "./src/project-js.ts";
 export { DBXToolsPythonProject, DBXToolsPythonWorkspace } from "./src/project-py.ts";
 export type { PythonRepositoryOptions, PythonPackageOptions, PythonTrustedPublisherOptions, DBXToolsPythonProjectOptions, PythonReleaseOptions, DBXToolsPythonWorkspaceOptions } from "./src/project-py.ts";
-export { DBXToolsRustProject, RustReleaseOs, RustReleaseCpu, UNIFFI_RELEASE_TARGETS, DBXToolsRustWorkspace } from "./src/project-rs.ts";
-export type { CargoDependency, CargoDependencyOptions, CargoExampleOptions, DBXToolsRustProjectOptions, RustCrateOptions, RustCliOptions, RustOpenApiOptions, DBXToolsRustWorkspaceOptions, RustReleasePlatform, UniFFIReleaseTarget, RustBindingMapping, RustOpenApiMapping, RustWorkspaceMapping, RustReleaseBinaryAssetMapping, RustReleaseBinaryMapping } from "./src/project-rs.ts";
 export { PROJEN_VERSION } from "./src/projen-version.ts";
 export { COMPILED_DIR, COMPILED_COMPILER_OPTIONS } from "./src/publish.ts";
+export type { ResolvedPythonNodeFunctionOverride, ResolvedPythonNodeBindings } from "./src/python-node-bindings.ts";
+export { PythonNodeBundle } from "./src/python-node-bundle.ts";
+export type { PythonNodeFunctionOverride, PythonNodeBindingsOptions, PythonNodeBundleOptions } from "./src/python-node-bundle.ts";
 export { DBXToolsRelease } from "./src/release.ts";
-export type { ReleaseStage, ReleaseDocsOptions, ReleaseSummaryOptions, DBXToolsReleaseOptions } from "./src/release.ts";
+export type { ReleaseStage, ReleaseDocsOptions, DBXToolsReleaseOptions } from "./src/release.ts";
 export { DBXToolsReleaseCatalog } from "./src/release-catalog.ts";
-export type { DBXToolsVersioningMode, ReleaseProjectLanguage, ReleaseArtifactKind, ReleaseEdgeKind, ReleasePropagation, ReleaseUnitRule, DBXToolsReleaseCatalogOptions, ReleaseDependencyInput, ReleaseProjectRegistration, ExternalReleaseProjectRegistration, ReleaseArtifactRegistration, ReleaseProjectNode, ReleaseArtifact, ReleaseDependencyEdge, ReleaseUnit, ReleaseUnitGraph } from "./src/release-catalog.ts";
-export { RELEASE_TAG, RELEASE_SHA, RELEASE_VERSION, RELEASE_SUMMARY_DIRECTORY, RELEASE_SUMMARY_PROVIDER_NAMES, RELEASE_SUMMARY_FILE } from "./src/release-dispatch.ts";
-export type { ReleaseSummaryProviderName } from "./src/release-dispatch.ts";
+export type { ReleaseProjectLanguage, ReleaseArtifactKind, ReleaseEdgeKind, ReleasePropagation, ReleaseUnitRule, DBXToolsReleaseCatalogOptions, ReleaseDependencyInput, ReleaseProjectRegistration, ExternalReleaseProjectRegistration, ReleaseArtifactRegistration, ReleaseProjectNode, ReleaseArtifact, ReleaseDependencyEdge, ReleaseUnit, ReleaseUnitGraph } from "./src/release-catalog.ts";
+export { RELEASE_TAG, RELEASE_SHA, RELEASE_VERSION } from "./src/release-context.ts";
 export type { GithubRepositoryIdentity, GithubAuthenticatedAccount, GithubRepositoryPermissions } from "./src/release-github.ts";
-export type { ReleaseReason, PlannedReleaseUnit, PlannedPackage, PlannedArtifact, PlannedRustTarget, ReleasePlan } from "./src/release-plan.ts";
-export { ReleaseUnitWorkspacePlugin } from "./src/release-please.ts";
-export type { ReleaseUnitWorkspacePluginOptions } from "./src/release-please.ts";
 export { AGNOSTIC_COMPILER_OPTIONS, PACKAGE_TAG_MIXINS } from "./src/tags.ts";
 export type { PackageTag } from "./src/tags.ts";
 export { DBXToolsRootTsconfig } from "./src/tsconfig.ts";
-export { makeDefaultedInterfaceParametersOptional, removeObsoleteInterfaceAliases, addTypeScriptExtensionsToBindingImports, addExplicitInterfaceReexports } from "./src/uniffi.ts";
-export type { TypeScriptBindingModule } from "./src/uniffi.ts";
 export { DBXToolsVsCode } from "./src/vscode.ts";
 export type { IgnoreGroupOptions, WatchLoopOptions } from "./src/watch.ts";
 export type { WorkspaceMutationLockOptions } from "./src/workspace-lock.ts";

package/package.json

@@ -1,5 +1,10 @@
 {
   "name": "@dbx-tools/projen",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/reggie-db/dbx-tools.git",
+    "directory": "projen"
+  },
   "scripts": {
     "build": "projen build",
     "clobber": "projen clobber",
@@ -29,16 +34,15 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.7.0",
-    "@dbx-tools/core": "^0.9.19",
-    "@dbx-tools/path": "^0.9.19",
-    "@dbx-tools/shared-core": "^0.9.19",
+    "@dbx-tools/core": "^0.9.28",
+    "@dbx-tools/path": "^0.9.28",
+    "@dbx-tools/shared-core": "^0.9.28",
     "commander": "^15.0.0",
     "concurrently": "^10.0.3",
     "constructs": "^10.6.0",
     "is-identifier": "^1",
     "openapi-typescript": "^7.13.0",
     "oxc-parser": "^0.90.0",
-    "release-please": "17.11.2",
     "semver": "^7.7.3",
     "smol-toml": "1.8.0",
     "ts-to-zod": "^5.1.0",
@@ -52,7 +56,7 @@
   },
   "main": "index.ts",
   "license": "Apache-2.0",
-  "version": "0.9.19",
+  "version": "0.9.28",
   "types": "index.ts",
   "type": "module",
   "exports": {

package/src/_task-command.ts

@@ -12,6 +12,13 @@ export interface CaptureTaskCommandOptions extends TaskCommandOptions {
   readonly check?: boolean;
 }
 
+export type ProbeTaskCommandOptions = TaskCommandOptions;
+
+export interface LoggedTaskCommandOptions extends TaskCommandOptions {
+  /** Receive normalized stdout and stderr lines after the command exits. */
+  readonly onLine: (line: string) => void;
+}
+
 function executable(command: string): string {
   return command === "bun" && process.versions.bun ? process.execPath : command;
 }
@@ -69,6 +76,47 @@ export function captureTaskCommand(
   return result.exitCode === 0 ? (result.stdout?.trim() ?? "") : "";
 }
 
+/** Capture trimmed stdout while preserving command failure as `undefined`. */
+export function probeTaskCommand(
+  cwd: string,
+  command: string,
+  args: readonly string[],
+  options: ProbeTaskCommandOptions = {},
+): string | undefined {
+  const result = exec.spawnSync(executable(command), [...args], {
+    cwd,
+    env: options.env,
+    stdout: "capture",
+    stderr: options.stderr ?? "ignore",
+    stdin: "ignore",
+    check: false,
+  });
+  return result.exitCode === 0 ? (result.stdout?.trim() ?? "") : undefined;
+}
+
+/** Run a checked command while routing captured output through one line policy. */
+export function runLoggedTaskCommand(
+  cwd: string,
+  command: string,
+  args: readonly string[],
+  options: LoggedTaskCommandOptions,
+): void {
+  const result = exec.spawnSync(executable(command), [...args], {
+    cwd,
+    env: options.env,
+    stdout: "capture",
+    stderr: "capture",
+    stdin: "ignore",
+    check: false,
+  });
+  for (const line of [...result.stdoutLines, ...result.stderrLines]) {
+    if (line) options.onLine(line);
+  }
+  if (result.exitCode !== 0) {
+    throw new Error(`${command} exited with ${result.exitCode}`);
+  }
+}
+
 /** Whether a quiet, non-interactive command exits successfully. */
 export function taskCommandSucceeds(
   cwd: string,
@@ -87,3 +135,30 @@ export function taskCommandSucceeds(
     }).exitCode === 0
   );
 }
+
+/** Run Git with the shared non-interactive checked command policy. */
+export function runGitTaskCommand(
+  cwd: string,
+  args: readonly string[],
+  options: TaskCommandOptions = {},
+): void {
+  runTaskCommand(cwd, "git", args, options);
+}
+
+/** Capture Git output, returning an empty string for optional offline probes. */
+export function captureGitTaskCommand(
+  cwd: string,
+  args: readonly string[],
+  options: CaptureTaskCommandOptions = {},
+): string {
+  return captureTaskCommand(cwd, "git", args, options);
+}
+
+/** Whether a quiet Git command succeeds. */
+export function gitTaskCommandSucceeds(
+  cwd: string,
+  args: readonly string[],
+  options: Pick<TaskCommandOptions, "env"> = {},
+): boolean {
+  return taskCommandSucceeds(cwd, "git", args, options);
+}