@dbx-tools/projen 0.6.60 → 0.6.62

package/README.md

@@ -124,35 +124,6 @@ package is attempted even if one fails; the failures are re-thrown together as a
 `AggregateError` naming each package, rather than the first one abandoning the
 rest of the sweep.
 
-### Generate Node And Python From Rosetta Sources
-
-The experimental `rs-packages` convention keeps TypeScript as the canonical
-Node implementation while colocating an explicit Python implementation in the
-same file:
-
-```ts
-export function capitalize(value: string): string {
-  return value ? value[0]!.toUpperCase() + value.slice(1) : value;
-}
-
-/* @rs-python
-def capitalize(value: str) -> str:
-    return value[:1].upper() + value[1:] if value else value
-@rs-end */
-```
-
-By default, `rs-packages/shared/core/src/string.ts` generates:
-
-- `packages/shared/core/src/string.ts`
-- `python-packages/shared-core/src/shared_core/string.py`
-
-Use `// @rs-node <path>` or `// @rs-python-path <path>` only when the inferred
-paths are unsuitable. Every Rosetta source must live below a package's `src/`
-folder and include at least one Python block; generation fails rather than
-silently emitting an empty Python module. `DBXToolsNodeProject` enables the
-`rs-packages` root by default, accepts `rsPackageRoots` for custom roots, and
-accepts `rsPackageRoots: false` to disable the experiment.
-
 ## Generate OpenAPI Clients
 
 ```ts
@@ -217,7 +188,6 @@ file contract as the CLI.
 - `pnpmWorkspace` - generated pnpm workspace file and catalog model.
 - `barrels` / `moduleExports` - public entrypoint generation.
 - `codegen` - `.d.ts` to zod schema generation.
-- `rsPackages` - annotated TypeScript source to Node/Python generation.
 - `openapi` - tsoa/OpenAPI package generation.
 - `bunApp` / `tsconfig` / `vscode` - generated support files/components.
 - `generated` / `clean` / `watch` / `scaffold` - read-only file stamping,
@@ -226,8 +196,8 @@ file contract as the CLI.
 - `engineRoot` - engine package root resolution for bootstrapped repos.
 
 The engine registers its commands as projen tasks on the workspace root, so run
-them with `bun run <task>` - `sync` (add `--watch`), `barrels`, `openapi`,
-`rs-packages` (also supports `--watch`), and `clean`.
+them with `bun run <task>` - `sync` (add `--watch`), `barrels`, `openapi`, and
+`clean`.
 [`@dbx-tools/cli`](../packages/cli/dbx-tools) is only needed to
 bootstrap a folder that has no `.projenrc.ts` or toolchain yet.
 
@@ -237,15 +207,14 @@ Every repo-wide task lives on the root, and the root's `compile` / `test`
 delegate with `bun run --filter '*'` rather than emitting a step per member - so
 a new package is covered without a re-synth. Work from the root:
 
-| Task                  | What it does                                       |
-| --------------------- | -------------------------------------------------- |
-| `bun run build`       | `compile` + `test` + `package` across every member |
-| `bun run compile`     | `tsc --build` in each member, in parallel          |
-| `bun run test`        | `eslint` once, then each member's tests            |
-| `bun run sync`        | re-synth (`--watch` to keep synthing)              |
-| `bun run barrels`     | regenerate the read-only `index.ts` barrels        |
-| `bun run rs-packages` | regenerate Node/Python Rosetta outputs             |
-| `bun run bump`        | version, tag, and publish                          |
+| Task              | What it does                                       |
+| ----------------- | -------------------------------------------------- |
+| `bun run build`   | `compile` + `test` + `package` across every member |
+| `bun run compile` | `tsc --build` in each member, in parallel          |
+| `bun run test`    | `eslint` once, then each member's tests            |
+| `bun run sync`    | re-synth (`--watch` to keep synthing)              |
+| `bun run barrels` | regenerate the read-only `index.ts` barrels        |
+| `bun run bump`    | version, tag, and publish                          |
 
 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

@@ -18,13 +18,20 @@ export * as project from "./src/project.ts";
 export * as projectPredicate from "./src/project-predicate.ts";
 export * as publish from "./src/publish.ts";
 export * as release from "./src/release.ts";
-export * as rsPackages from "./src/rs-packages.ts";
 export * as scaffold from "./src/scaffold.ts";
 export * as tags from "./src/tags.ts";
 export * as tsconfig from "./src/tsconfig.ts";
 export * as vscode from "./src/vscode.ts";
 export * as watch from "./src/watch.ts";
-export { BUN_DEV_OVERRIDE, BUN_BUILD_OVERRIDE, BUN_APP_OVERRIDES, RootBunfigFile, BunfigFile, BunDevServerFile, BunBuildFile } from "./src/bun-app.ts";
+export {
+  BUN_DEV_OVERRIDE,
+  BUN_BUILD_OVERRIDE,
+  BUN_APP_OVERRIDES,
+  RootBunfigFile,
+  BunfigFile,
+  BunDevServerFile,
+  BunBuildFile,
+} from "./src/bun-app.ts";
 export { DBXToolsConfig } from "./src/dbx-tools-config.ts";
 export type { DBXToolsConfigOptions } from "./src/dbx-tools-config.ts";
 export { resolvePkgRoot } from "./src/engine-root.ts";
@@ -35,13 +42,21 @@ 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 { PackageIdentifier, PROJEN_VERSION, DBXToolsNodeProject, DBXToolsTypeScriptProject } from "./src/project.ts";
-export type { DBXToolsProject, DBXToolsProjectOptions, DBXToolsTypeScriptProjectOptions, ApplyToProjectsOptions } from "./src/project.ts";
+export {
+  PackageIdentifier,
+  PROJEN_VERSION,
+  DBXToolsNodeProject,
+  DBXToolsTypeScriptProject,
+} from "./src/project.ts";
+export type {
+  DBXToolsProject,
+  DBXToolsProjectOptions,
+  DBXToolsTypeScriptProjectOptions,
+  ApplyToProjectsOptions,
+} from "./src/project.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";
-export { DEFAULT_RS_PACKAGE_ROOTS, RsPackages } from "./src/rs-packages.ts";
-export type { RsPackageOutput, GenerateRsPackagesOptions } from "./src/rs-packages.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";

package/package.json

@@ -26,9 +26,9 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.7.0",
-    "@dbx-tools/core": "0.6.60",
-    "@dbx-tools/path": "0.6.60",
-    "@dbx-tools/shared-core": "0.6.60",
+    "@dbx-tools/core": "0.6.62",
+    "@dbx-tools/path": "0.6.62",
+    "@dbx-tools/shared-core": "0.6.62",
     "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.60",
+  "version": "0.6.62",
   "types": "index.ts",
   "type": "module",
   "exports": {

package/src/codegen.ts

@@ -46,10 +46,10 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { basename, dirname, join, resolve } from "node:path";
+import { log, object } from "@dbx-tools/shared-core";
 import type * as ts from "typescript";
 import { lazyRequire } from "./_lazy-require.ts";
 import { header, isReadonly, makeReadonly, makeWritable } from "./generated.ts";
-import { log, object } from "@dbx-tools/shared-core";
 import { readPackageManifest, repoRoot, recordedPackages } from "./packages.ts";
 
 const logger = log.logger("projen:codegen");

package/src/dbx-tools-config.ts

@@ -31,11 +31,12 @@ function readDBXToolsConfig(pkg: javascript.NodePackage): Record<string, unknown
 
 function loadConfig(dbxToolsConfig: DBXToolsConfig, pkg: javascript.NodePackage) {
   const { tags, ...config } = readDBXToolsConfig(pkg);
-  if (Array.isArray(tags))
+  if (Array.isArray(tags)) {
     object
       .sequence(tags)
       .filter((v: unknown) => typeof v === "string")
       .forEach((v: string) => dbxToolsConfig.tags.push(v));
+  }
   Object.entries(config).forEach(([key, value]) => {
     dbxToolsConfig[key] = value;
   });

package/src/openapi.ts

@@ -23,11 +23,11 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { join } from "node:path";
-import type * as ts from "typescript";
 import { find } from "@dbx-tools/path";
+import { log } from "@dbx-tools/shared-core";
+import type * as ts from "typescript";
 import { lazyRequire } from "./_lazy-require.ts";
 import { makeReadonly, makeWritable, stampGenerated } from "./generated.ts";
-import { log } from "@dbx-tools/shared-core";
 import {
   type RecordedPackage,
   isModuleFile,

package/src/packages.ts

@@ -26,8 +26,8 @@
 import { existsSync, readFileSync } from "node:fs";
 import { extname, relative, resolve, sep } from "node:path";
 import { project as coreProject } from "@dbx-tools/core";
-import { json, object, string } from "@dbx-tools/shared-core";
 import { find } from "@dbx-tools/path";
+import { json, object, string } from "@dbx-tools/shared-core";
 import { parse } from "yaml";
 
 /**

package/src/project-predicate.ts

@@ -1,3 +1,5 @@
+import { relative } from "node:path";
+import { match, PathMatchInput, PathMatchPredicate } from "@dbx-tools/path";
 import {
   object,
   predicate,
@@ -7,11 +9,9 @@ import {
 } from "@dbx-tools/shared-core";
 import { IConstruct } from "constructs";
 import { Project } from "projen";
-import { DBXToolsProject, DBXToolsNodeProject, DBXToolsTypeScriptProject } from "./project.ts";
-import { toPosix } from "./packages.ts";
-import { relative } from "node:path";
-import { match, PathMatchInput, PathMatchPredicate } from "@dbx-tools/path";
 import { project } from "..";
+import { toPosix } from "./packages.ts";
+import { DBXToolsProject, DBXToolsNodeProject, DBXToolsTypeScriptProject } from "./project.ts";
 
 /**
  * Guard: the construct is a projen {@link Project} - the base every builder here

package/src/project.ts

@@ -6,22 +6,16 @@
  * {@link DBXToolsNodeProject} (monorepo root) and {@link DBXToolsTypeScriptProject}
  * (a package, or a standalone compiling root) both implement {@link DBXToolsProject}.
  */
-import { object, string, type OneOrMany } from "@dbx-tools/shared-core";
-import { ignore, match, PathMatchInput } from "@dbx-tools/path";
-import { project as coreProject } from "@dbx-tools/core";
 import { existsSync, readdirSync } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
+import { project as coreProject } from "@dbx-tools/core";
+import { ignore, match, PathMatchInput } from "@dbx-tools/path";
+import { object, string, type OneOrMany } from "@dbx-tools/shared-core";
+import { IConstruct } from "constructs";
 import { Component, IgnoreFile, Project, type TaskOptions, javascript, typescript } from "projen";
 import { ReleaseTrigger } from "projen/lib/release";
+import { mixin, projectPredicate } from "..";
 import { generateBarrels } from "./barrels.ts";
-import { codegenModulePaths, generateCodegen } from "./codegen.ts";
-import { DBXToolsConfig, type DBXToolsConfigOptions } from "./dbx-tools-config.ts";
-import { resolvePkgRoot } from "./engine-root.ts";
-import { PnpmWorkspaceState, type DBXToolsPNPMWorkspaceOptions } from "./pnpm-workspace.ts";
-import { applyCompiledPublish } from "./publish.ts";
-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 {
   BUN_APP_OVERRIDES,
   BunBuildFile,
@@ -29,8 +23,9 @@ import {
   BunfigFile,
   RootBunfigFile,
 } from "./bun-app.ts";
-import { DBXToolsVsCode } from "./vscode.ts";
-import { DEFAULT_RS_PACKAGE_ROOTS, RsPackages } from "./rs-packages.ts";
+import { codegenModulePaths, generateCodegen } from "./codegen.ts";
+import { DBXToolsConfig, type DBXToolsConfigOptions } from "./dbx-tools-config.ts";
+import { resolvePkgRoot } from "./engine-root.ts";
 import {
   DEFAULT_PACKAGE_ROOTS,
   type DiscoveredPackage,
@@ -40,8 +35,12 @@ import {
   scanPackages,
   toPosix,
 } from "./packages.ts";
-import { mixin, projectPredicate } from "..";
-import { IConstruct } from "constructs";
+import { PnpmWorkspaceState, type DBXToolsPNPMWorkspaceOptions } from "./pnpm-workspace.ts";
+import { applyCompiledPublish } from "./publish.ts";
+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";
 
 /**
  * The dbx-tools project surface, backed by projen's Node toolchain. A single
@@ -520,11 +519,6 @@ export interface DBXToolsProjectOptions
    * is a member of the single bun workspace, so the root links it from source.
    */
   readonly extraWorkspaceMembers?: readonly string[];
-  /**
-   * Experimental TypeScript-to-Node/Python source roots. Defaults to
-   * `["rs-packages"]`; set `false` to disable the generator.
-   */
-  readonly rsPackageRoots?: readonly string[] | false;
 }
 
 /** Options for {@link DBXToolsTypeScriptProject} (a package, or a compiling root). */
@@ -847,7 +841,6 @@ function registerRootTasks(project: javascript.NodeProject): void {
   applyTasks(project, {
     barrels: { exec: taskScript(project, "barrels.ts") },
     openapi: { exec: taskScript(project, "openapi.ts") },
-    "rs-packages": { exec: taskScript(project, "rs-packages.ts"), receiveArgs: true },
     clean: { exec: taskScript(project, "clean.ts"), receiveArgs: true },
     // `receiveArgs` forwards `--watch`, so `bun run sync -- --watch` syncs once
     // then starts the single node-path watcher loop.
@@ -932,13 +925,6 @@ function initProject(
   project.vsCode = new DBXToolsVsCode(project);
 
   registerRootTasks(project);
-  project.dbxToolsConfig.rsPackageRoots =
-    options.rsPackageRoots === false
-      ? false
-      : [...(options.rsPackageRoots ?? DEFAULT_RS_PACKAGE_ROOTS)];
-  if (options.rsPackageRoots !== false) {
-    new RsPackages(project, options.rsPackageRoots ?? DEFAULT_RS_PACKAGE_ROOTS);
-  }
   if (options.prettier || project.prettier) {
     const formatTask = project.tasks.tryFind("format") ?? project.addTask("format");
     formatTask.prependExec("prettier . --write", { receiveArgs: true });
@@ -967,14 +953,20 @@ function initProject(
   // each file to its own package tsconfig (so type-aware rules work tree-wide), and
   // `import/no-extraneous-dependencies` still checks each file against its nearest
   // package.json. Formatting defers to the root Prettier to avoid rule/formatter
-  // conflicts (e.g. quote style). Spawned from `test`, so ignorePatterns must cover
-  // every read-only generated path - `--fix` EACCES-crashes on them otherwise.
+  // conflicts (e.g. quote style). The normal task is check-only so CI never
+  // repairs the worktree it is meant to validate; `eslint:fix` is the explicit
+  // local mutation path.
   const eslint = new javascript.Eslint(project, {
-    dirs: [...roots],
+    dirs: [...roots, "projen"],
     fileExtensions: [".ts", ".tsx"],
     projectService: true,
     prettier: Boolean(project.prettier),
     tsconfigPath: "./tsconfig.json",
+    commandOptions: { fix: false },
+  });
+  project.addTask("eslint:fix", {
+    description: "Fix ESLint issues across the codebase",
+    exec: "bun run eslint -- --fix",
   });
   // Generated read-only outputs (barrels, openapi clients, app scripts, codegen).
   // ESLint --fix cannot rewrite them; they are stamped by the barrel generator /
@@ -983,6 +975,7 @@ function initProject(
     eslint.addIgnorePattern(`${root}/openapi/**`);
     eslint.addIgnorePattern(`${root}/**/index.ts`);
   }
+  eslint.addIgnorePattern("projen/index.ts");
   // The generated bun app scripts + unmanaged overrides live at the package root,
   // outside any `src/**` tsconfig include, so the type-aware parser cannot resolve
   // them to a project. ESLint still cannot parse them.
@@ -1256,21 +1249,24 @@ export function applyToProjects<P extends Project>(
   let pred = projectPredicate.isProject();
   if (!options?.includeNonDBXToolsProjects) pred = pred.and(projectPredicate.isDBXToolsProject());
   if (!options?.includeRoots) pred = pred.and((p) => p.parent != null);
-  if (options?.identifierPackageName)
+  if (options?.identifierPackageName) {
     pred = pred.and(
       projectPredicate.hasIdentifierPackageName(
         ...object.toOneOrMany(options.identifierPackageName),
       ),
     );
+  }
   if (options?.name) pred = pred.and(projectPredicate.hasName(...object.toOneOrMany(options.name)));
-  if (options?.identifierScope)
+  if (options?.identifierScope) {
     pred = pred.and(
       projectPredicate.hasIdentifierScope(...object.toOneOrMany(options.identifierScope)),
     );
-  if (options?.identifierName)
+  }
+  if (options?.identifierName) {
     pred = pred.and(
       projectPredicate.hasIdentifierName(...object.toOneOrMany(options.identifierName)),
     );
+  }
   if (options?.tags) pred = pred.and(projectPredicate.hasTag(...object.toOneOrMany(options.tags)));
   if (options?.path) pred = pred.and(projectPredicate.hasPath(...object.toOneOrMany(options.path)));
   const projectMixin = mixin.create(pred, (p) => {

package/src/publish.ts

@@ -29,8 +29,8 @@
  */
 import type { javascript } from "projen";
 import { typescript } from "projen";
-import { addPackageFiles, applyCompilerOptions, applyIncludes } from "./project.ts";
 import { isDBXToolsProject } from "./project-predicate.ts";
+import { addPackageFiles, applyCompilerOptions, applyIncludes } from "./project.ts";
 
 /** Directory `tsc` emits into, and the root of every published entry point. */
 export const COMPILED_DIR = "lib";

package/src/tags.ts

@@ -17,6 +17,7 @@ import type { IMixin as ConstructsMixin } from "constructs";
 import { javascript } from "projen";
 import { BunBuildFile, BunDevServerFile, BunfigFile } from "./bun-app.ts";
 import { create } from "./mixin.ts";
+import * as projectPredicate from "./project-predicate.ts";
 import {
   addPackageFiles,
   applyCompilerOptions,
@@ -25,7 +26,6 @@ import {
   applyTasks,
   srcModuleExports,
 } from "./project.ts";
-import * as projectPredicate from "./project-predicate.ts";
 
 /** Node compiler options: ES2022 lib + node types, deliberately no DOM. */
 const NODE_COMPILER_OPTIONS: javascript.TypeScriptCompilerOptions = {
@@ -137,7 +137,7 @@ export const PACKAGE_TAG_MIXINS = {
     // register and no launcher shim to generate. In a WORKSPACE checkout the
     // manifest still points at the `.ts` entry, which Node type-strips on its own
     // because the package is not under `node_modules`.
-    p.addDeps("commander@catalog:", "@clack/prompts@catalog:");
+    p.addDeps("commander@catalog:");
     p.addDevDeps("@types/node@catalog:");
     // A CLI compiles code OUTSIDE `src/` - its root `index.ts` barrel and the
     // `bin/` entries - which the src-only tag default doesn't reach.

package/tasks/barrels.ts

@@ -1,9 +1,9 @@
 #!/usr/bin/env -S bun
 import { sep } from "node:path";
-import { generateBarrels } from "../src/barrels.ts";
 import { log, string } from "@dbx-tools/shared-core";
-import { watchLoop, watchRoots } from "../src/watch.ts";
+import { generateBarrels } from "../src/barrels.ts";
 import { recordedPackages } from "../src/packages.ts";
+import { watchLoop, watchRoots } from "../src/watch.ts";
 
 const logger = log.logger("projen:barrels");
 

package/tasks/bump.ts

@@ -39,12 +39,12 @@
  *   - `false`: never publish locally.
  *   - a URL: always publish to that registry.
  */
-import { exec, project } from "@dbx-tools/core";
-import { log, net } from "@dbx-tools/shared-core";
-import { Command, Option } from "commander";
 import { chmodSync, existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 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";
 
 const logger = log.logger("projen:bump");
 const LEVELS = ["patch", "minor", "major"] as const;

package/tasks/clean.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env -S bun
 import { relative } from "node:path";
-import { listGeneratedFiles, listNodeModulesDirs, removePaths } from "../src/clean.ts";
 import { log, string } from "@dbx-tools/shared-core";
+import { listGeneratedFiles, listNodeModulesDirs, removePaths } from "../src/clean.ts";
 import { repoRoot, toPosix } from "../src/packages.ts";
 
 const logger = log.logger("projen:clean");

package/tasks/openapi.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env -S bun
-import { generateBarrels } from "../src/barrels.ts";
 import { log, string } from "@dbx-tools/shared-core";
+import { generateBarrels } from "../src/barrels.ts";
 import { generateOpenapi, isTsoaController } from "../src/openapi.ts";
 import { runSynth } from "../src/scaffold.ts";
 import { watchLoop, watchRoots } from "../src/watch.ts";

package/tasks/projenrc.ts

@@ -1,9 +1,9 @@
 #!/usr/bin/env -S bun
 import { resolve } from "node:path";
 import { log } from "@dbx-tools/shared-core";
+import { repoRoot, syncResynthPaths } from "../src/packages.ts";
 import { runSynth } from "../src/scaffold.ts";
 import { watchLoop } from "../src/watch.ts";
-import { repoRoot, syncResynthPaths } from "../src/packages.ts";
 
 const logger = log.logger("projen:projenrc");
 

package/tasks/sync.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env -S bun
 import { fileURLToPath } from "node:url";
-import concurrently from "concurrently";
 import { log } from "@dbx-tools/shared-core";
+import concurrently from "concurrently";
 import { runSynth } from "../src/scaffold.ts";
 
 const logger = log.logger("projen:sync");
@@ -57,11 +57,6 @@ if (!process.argv.includes("--watch")) {
       { command: `bun "${taskPath("projenrc.ts")}"`, name: "projenrc", prefixColor: "magenta" },
       { command: `bun "${taskPath("barrels.ts")}" --watch`, name: "barrels", prefixColor: "cyan" },
       { command: `bun "${taskPath("openapi.ts")}" --watch`, name: "openapi", prefixColor: "green" },
-      {
-        command: `bun "${taskPath("rs-packages.ts")}" --watch`,
-        name: "rs-packages",
-        prefixColor: "yellow",
-      },
     ],
     {
       prefix: "name",

package/src/rs-packages.ts

@@ -1,237 +0,0 @@
-/**
- * Experimental Rosetta-source generation.
- *
- * A TypeScript file under `rs-packages/<package>/src/` is the canonical Node
- * implementation. Projen copies its TypeScript surface to the matching
- * `packages/<package>/src/` path and extracts one or more `@rs-python` blocks
- * into a conventional Python package path.
- */
-import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
-import { dirname, extname, join, relative, resolve } from "node:path";
-import { json, object } from "@dbx-tools/shared-core";
-import { Component, javascript } from "projen";
-import { header, makeReadonly, makeWritable } from "./generated.ts";
-import { toPosix } from "./packages.ts";
-
-export const DEFAULT_RS_PACKAGE_ROOTS = ["rs-packages"] as const;
-
-const SOURCE_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
-const PYTHON_BLOCK = /\/\*\s*@rs-python\s*\n([\s\S]*?)\n\s*@rs-end\s*\*\//g;
-const NODE_OVERRIDE = /^\s*\/\/\s*@rs-node\s+(.+?)\s*$/m;
-const PYTHON_OVERRIDE = /^\s*\/\/\s*@rs-python-path\s+(.+?)\s*$/m;
-const RS_METADATA = /^\s*\/\/\s*@rs-(?:node|python-path)\s+.+?\s*$\n?/gm;
-const NODE_MARKER = "// GENERATED by projen synth (rs-packages)";
-const PYTHON_MARKER = "# GENERATED by projen synth (rs-packages)";
-
-export interface RsPackageOutput {
-  readonly source: string;
-  readonly node: string;
-  readonly python: string;
-}
-
-export interface GenerateRsPackagesOptions {
-  readonly projectRoot?: string;
-  readonly roots?: readonly string[];
-}
-
-function sourceFiles(root: string): string[] {
-  if (!existsSync(root)) return [];
-  const files: string[] = [];
-  const visit = (dir: string): void => {
-    for (const entry of readdirSync(dir)) {
-      const path = join(dir, entry);
-      if (statSync(path).isDirectory()) visit(path);
-      else if (SOURCE_EXTENSIONS.has(extname(entry))) files.push(path);
-    }
-  };
-  visit(root);
-  return files.sort();
-}
-
-function dedent(value: string): string {
-  const lines = value.replace(/^\n+|\n+$/g, "").split("\n");
-  const indents = lines
-    .filter((line) => line.trim())
-    .map((line) => line.match(/^\s*/)?.[0].length ?? 0);
-  const width = indents.length ? Math.min(...indents) : 0;
-  return lines.map((line) => line.slice(width)).join("\n");
-}
-
-function defaultOutputPaths(
-  projectRoot: string,
-  root: string,
-  source: string,
-): Pick<RsPackageOutput, "node" | "python"> {
-  const sourceRelative = toPosix(relative(resolve(projectRoot, root), source));
-  const segments = sourceRelative.split("/");
-  const srcIndex = segments.indexOf("src");
-  if (srcIndex < 1) {
-    throw new Error(
-      `Rosetta source must live under <package>/src/: ${toPosix(relative(projectRoot, source))}`,
-    );
-  }
-
-  const packageSegments = segments.slice(0, srcIndex);
-  const moduleSegments = segments.slice(srcIndex + 1);
-  const moduleFile = moduleSegments.pop();
-  if (!moduleFile) throw new Error(`Rosetta source has no module name: ${source}`);
-
-  const pythonDistribution = packageSegments.join("-");
-  const pythonImport = packageSegments.join("_").replace(/-/g, "_");
-  const pythonModule = `${moduleFile.slice(0, -extname(moduleFile).length).replace(/-/g, "_")}.py`;
-
-  return {
-    node: resolve(
-      projectRoot,
-      "packages",
-      ...packageSegments,
-      "src",
-      ...moduleSegments,
-      moduleFile,
-    ),
-    python: resolve(
-      projectRoot,
-      "python-packages",
-      pythonDistribution,
-      "src",
-      pythonImport,
-      ...moduleSegments,
-      pythonModule,
-    ),
-  };
-}
-
-function resolveOutput(
-  projectRoot: string,
-  override: RegExpMatchArray | null,
-  fallback: string,
-): string {
-  const value = override?.[1]?.trim();
-  return value ? resolve(projectRoot, value) : fallback;
-}
-
-function assertWritableOutput(projectRoot: string, path: string, marker: string): void {
-  if (!existsSync(path)) return;
-  if (readFileSync(path, "utf8").startsWith(marker)) return;
-  throw new Error(
-    `Refusing to overwrite hand-authored Rosetta output: ${toPosix(relative(projectRoot, path))}`,
-  );
-}
-
-function renderSource(projectRoot: string, root: string, source: string): RsPackageOutput {
-  const input = readFileSync(source, "utf8");
-  const defaults = defaultOutputPaths(projectRoot, root, source);
-  const node = resolveOutput(projectRoot, input.match(NODE_OVERRIDE), defaults.node);
-  const python = resolveOutput(projectRoot, input.match(PYTHON_OVERRIDE), defaults.python);
-  const pythonBlocks = [...input.matchAll(PYTHON_BLOCK)].map((match) => dedent(match[1] ?? ""));
-
-  if (!pythonBlocks.length) {
-    throw new Error(
-      `Rosetta source needs at least one /* @rs-python ... @rs-end */ block: ${toPosix(relative(projectRoot, source))}`,
-    );
-  }
-
-  const nodeBody = input.replace(PYTHON_BLOCK, "").replace(RS_METADATA, "").trim();
-  const nodeContent = `${header({
-    tool: "projen synth (rs-packages)",
-    source: toPosix(relative(projectRoot, source)),
-  })}\n${nodeBody}\n`;
-  const pythonContent = [
-    "# GENERATED by projen synth (rs-packages) - DO NOT EDIT.",
-    `# Regenerated from ${toPosix(relative(projectRoot, source))}.`,
-    "# Hand edits are overwritten; edit the Rosetta source instead.",
-    "",
-    pythonBlocks.join("\n\n"),
-    "",
-  ].join("\n");
-
-  for (const [path, content] of [
-    [node, nodeContent],
-    [python, pythonContent],
-  ] as const) {
-    assertWritableOutput(projectRoot, path, path === node ? NODE_MARKER : PYTHON_MARKER);
-    mkdirSync(dirname(path), { recursive: true });
-    makeWritable(path);
-    writeFileSync(path, content);
-    makeReadonly(path);
-  }
-
-  return { source, node, python };
-}
-
-/** Read the roots recorded by synth for standalone tasks and watchers. */
-export function configuredRsPackageRoots(projectRoot: string): readonly string[] | false {
-  const manifest = json.parseRecord(readFileSync(resolve(projectRoot, "package.json"), "utf8"));
-  const config = object.isRecord(manifest?.dbxToolsConfig) ? manifest.dbxToolsConfig : undefined;
-  const configured = config?.rsPackageRoots;
-  if (configured === false) return false;
-  if (Array.isArray(configured)) {
-    const roots = configured.filter(
-      (value): value is string => typeof value === "string" && !!value,
-    );
-    if (roots.length) return roots;
-  }
-  return DEFAULT_RS_PACKAGE_ROOTS;
-}
-
-export function discoverRsPackageOutputs(
-  options: GenerateRsPackagesOptions = {},
-): RsPackageOutput[] {
-  const projectRoot = resolve(options.projectRoot ?? process.cwd());
-  const roots = options.roots ?? DEFAULT_RS_PACKAGE_ROOTS;
-  return roots.flatMap((root) =>
-    sourceFiles(resolve(projectRoot, root)).map((source) => {
-      const defaults = defaultOutputPaths(projectRoot, root, source);
-      const input = readFileSync(source, "utf8");
-      return {
-        source,
-        node: resolveOutput(projectRoot, input.match(NODE_OVERRIDE), defaults.node),
-        python: resolveOutput(projectRoot, input.match(PYTHON_OVERRIDE), defaults.python),
-      };
-    }),
-  );
-}
-
-export function generateRsPackages(options: GenerateRsPackagesOptions = {}): RsPackageOutput[] {
-  const projectRoot = resolve(options.projectRoot ?? process.cwd());
-  const roots = options.roots ?? DEFAULT_RS_PACKAGE_ROOTS;
-  return roots.flatMap((root) =>
-    sourceFiles(resolve(projectRoot, root)).map((source) =>
-      renderSource(projectRoot, root, source),
-    ),
-  );
-}
-
-/** Projen lifecycle component that regenerates Rosetta outputs after synth. */
-export class RsPackages extends Component {
-  private readonly outputs: RsPackageOutput[];
-
-  constructor(
-    project: javascript.NodeProject,
-    private readonly roots: readonly string[] = DEFAULT_RS_PACKAGE_ROOTS,
-  ) {
-    super(project);
-    // Generate during construction so a brand-new Node package exists before the
-    // root's package scan later in the same synth. postSynthesize repeats this to
-    // restore outputs after projen has written the rest of the tree.
-    this.outputs = generateRsPackages({ projectRoot: project.outdir, roots });
-    for (const output of this.outputs) {
-      const node = `/${toPosix(relative(project.outdir, output.node))}`;
-      const python = `/${toPosix(relative(project.outdir, output.python))}`;
-      project.annotateGenerated(node);
-      project.annotateGenerated(python);
-    }
-  }
-
-  public override preSynthesize(): void {
-    const eslint = javascript.Eslint.of(this.project);
-    if (!eslint) return;
-    for (const output of this.outputs) {
-      eslint.addIgnorePattern(toPosix(relative(this.project.outdir, output.node)));
-    }
-  }
-
-  public override postSynthesize(): void {
-    generateRsPackages({ projectRoot: this.project.outdir, roots: this.roots });
-  }
-}

package/tasks/rs-packages.ts

@@ -1,26 +0,0 @@
-import { existsSync } from "node:fs";
-import { resolve } from "node:path";
-import { log } from "@dbx-tools/shared-core";
-import { configuredRsPackageRoots, generateRsPackages } from "../src/rs-packages.ts";
-import { repoRoot } from "../src/packages.ts";
-import { watchLoop } from "../src/watch.ts";
-
-const logger = log.logger("projen:rs-packages");
-const configuredRoots = configuredRsPackageRoots(repoRoot);
-const roots = configuredRoots === false ? [] : configuredRoots;
-const watchRoots = roots.map((root) => resolve(repoRoot, root)).filter(existsSync);
-
-function generate(): void {
-  const outputs = generateRsPackages({ projectRoot: repoRoot, roots });
-  logger.success(`generated ${outputs.length} Rosetta module${outputs.length === 1 ? "" : "s"}`);
-}
-
-generate();
-
-if (process.argv.includes("--watch")) {
-  if (watchRoots.length) watchLoop("rs-packages", watchRoots, generate);
-  else {
-    logger.info("no Rosetta roots configured; watcher is idle");
-    setInterval(() => {}, 2_147_483_647);
-  }
-}