@dbx-tools/projen 0.9.21 → 0.9.29

package/tasks/release-summary.ts

@@ -1,379 +0,0 @@
-#!/usr/bin/env -S bun
-/**
- * Optional AI-generated release summary with CLI fallback.
- *
- * @module
- */
-import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import * as exec from "@dbx-tools/core/exec";
-import * as projectUtils from "@dbx-tools/core/project-utils";
-import { json, log, object, stringUtils } from "@dbx-tools/shared-core";
-import { captureTaskCommand } from "../src/_task-command.ts";
-import {
-  RELEASE_SUMMARY_PROVIDER_NAMES,
-  releaseSummaryFile,
-  type ReleaseSummaryProviderName,
-} from "../src/release-dispatch.ts";
-
-const logger = log.logger("projen:release-summary");
-const PROVIDER_TIMEOUT_MS = 60_000;
-const PROVIDER_KILL_GRACE_MS = 5_000;
-
-export interface ReleaseSummaryProvider {
-  readonly name: ReleaseSummaryProviderName;
-  readonly command: string;
-  readonly probeArgs: readonly string[];
-  args(root: string, prompt: string): string[];
-}
-
-export const RELEASE_SUMMARY_PROVIDERS: readonly ReleaseSummaryProvider[] = [
-  {
-    name: "cursor",
-    command: "cursor",
-    probeArgs: ["agent", "--version"],
-    args: (root, prompt) => [
-      "agent",
-      "--print",
-      "--mode",
-      "ask",
-      "--output-format",
-      "stream-json",
-      "--trust",
-      "--workspace",
-      root,
-      prompt,
-    ],
-  },
-  {
-    name: "codex",
-    command: "codex",
-    probeArgs: ["--version"],
-    args: (root, prompt) => [
-      "exec",
-      "--sandbox",
-      "read-only",
-      "--skip-git-repo-check",
-      "--json",
-      "--color",
-      "never",
-      "-C",
-      root,
-      prompt,
-    ],
-  },
-  {
-    name: "claude",
-    command: "claude",
-    probeArgs: ["--version"],
-    args: (_root, prompt) => [
-      "--print",
-      "--no-session-persistence",
-      "--output-format",
-      "stream-json",
-      "--verbose",
-      "--tools",
-      "",
-      prompt,
-    ],
-  },
-];
-
-export type ReleaseSummaryRunner = (
-  provider: ReleaseSummaryProvider,
-  root: string,
-  prompt: string,
-) => string | undefined | Promise<string | undefined>;
-
-function contentText(value: unknown): string | undefined {
-  if (typeof value === "string") return stringUtils.trimToNull(value) ?? undefined;
-  if (!Array.isArray(value)) return undefined;
-  const text = value
-    .flatMap((item) => (object.isRecord(item) && typeof item.text === "string" ? [item.text] : []))
-    .join("");
-  return stringUtils.trimToNull(text) ?? undefined;
-}
-
-function eventText(event: Record<string, unknown>): string | undefined {
-  if (typeof event.result === "string") return stringUtils.trimToNull(event.result) ?? undefined;
-  const item = object.isRecord(event.item) ? event.item : undefined;
-  if (item?.type === "agent_message" && typeof item.text === "string") {
-    return stringUtils.trimToNull(item.text) ?? undefined;
-  }
-  const message = object.isRecord(event.message) ? event.message : undefined;
-  return contentText(message?.content);
-}
-
-function eventType(event: Record<string, unknown>): string {
-  const item = object.isRecord(event.item) ? event.item : undefined;
-  return [event.type, item?.type].filter((value) => typeof value === "string").join(":") || "event";
-}
-
-function eventDetail(event: Record<string, unknown>): string | undefined {
-  const item = object.isRecord(event.item) ? event.item : undefined;
-  for (const value of [item?.message, event.message, event.error]) {
-    if (typeof value === "string") return stringUtils.trimToNull(value) ?? undefined;
-  }
-  return undefined;
-}
-
-function eventToolName(event: Record<string, unknown>): string | undefined {
-  const item = object.isRecord(event.item) ? event.item : undefined;
-  for (const value of [event.tool_name, event.toolName, event.name, item?.tool_name, item?.name]) {
-    if (typeof value === "string") return stringUtils.trimToNull(value) ?? undefined;
-  }
-  const toolCall = object.isRecord(event.tool_call)
-    ? event.tool_call
-    : object.isRecord(event.toolCall)
-      ? event.toolCall
-      : undefined;
-  const wrapper = toolCall
-    ? Object.keys(toolCall).find(
-        (key) => key.endsWith("ToolCall") && object.isRecord(toolCall[key]),
-      )
-    : undefined;
-  return wrapper ? wrapper.slice(0, -"ToolCall".length) : undefined;
-}
-
-/** Normalize one provider event into the fields retained in release logs. */
-export function releaseSummaryProviderEvent(event: Record<string, unknown>): {
-  type: string;
-  text?: string;
-  detail?: string;
-  tool?: string;
-} {
-  const text = eventText(event);
-  const detail = eventDetail(event);
-  const tool = eventToolName(event);
-  return {
-    type: eventType(event),
-    ...(text ? { text } : {}),
-    ...(detail ? { detail } : {}),
-    ...(tool ? { tool } : {}),
-  };
-}
-
-async function runProvider(
-  provider: ReleaseSummaryProvider,
-  root: string,
-  prompt: string,
-): Promise<string | undefined> {
-  if (!captureTaskCommand(root, provider.command, [...provider.probeArgs])) return undefined;
-  let summary: string | undefined;
-  let previousEventKey: string | undefined;
-  const textOutput: string[] = [];
-  const logEvent = (event: Record<string, unknown>) => {
-    const fields = { provider: provider.name, ...event };
-    const key = JSON.stringify(fields);
-    if (key === previousEventKey) return;
-    previousEventKey = key;
-    logger.info("provider-event", fields);
-  };
-  const child = exec.spawn(provider.command, provider.args(root, prompt), {
-    cwd: root,
-    stdout: [
-      "capture",
-      (line) => {
-        const event = json.parseRecord(line);
-        if (!event) {
-          const text = stringUtils.trimToNull(line);
-          if (text) {
-            textOutput.push(text);
-            logEvent({ type: "text", text });
-          }
-          return;
-        }
-        const fields = releaseSummaryProviderEvent(event);
-        if (fields.text) summary = fields.text;
-        logEvent(fields);
-      },
-    ],
-    stderr: (line) => {
-      const message = stringUtils.trimToNull(line);
-      if (message) logger.warn("provider-stderr", { provider: provider.name, message });
-    },
-    stdin: "ignore",
-    check: false,
-  });
-  let escalation: ReturnType<typeof setTimeout> | undefined;
-  const timeout = setTimeout(() => {
-    logger.warn("provider-timeout", {
-      provider: provider.name,
-      timeoutMs: PROVIDER_TIMEOUT_MS,
-    });
-    child.kill("SIGTERM");
-    escalation = setTimeout(() => child.kill("SIGKILL"), PROVIDER_KILL_GRACE_MS);
-    escalation.unref();
-  }, PROVIDER_TIMEOUT_MS);
-  timeout.unref();
-  const result = await child.finally(() => {
-    clearTimeout(timeout);
-    if (escalation) clearTimeout(escalation);
-  });
-  if (result.exitCode !== 0) {
-    logger.warn("provider-failed", { provider: provider.name, exitCode: result.exitCode });
-    return undefined;
-  }
-  return summary ?? (textOutput.length ? textOutput.join("\n") : undefined);
-}
-
-/** Return the first non-empty provider response in Cursor, Codex, Claude order. */
-export async function selectReleaseSummary(
-  root: string,
-  prompt: string,
-  runner: ReleaseSummaryRunner = runProvider,
-  providers: readonly ReleaseSummaryProviderName[] = RELEASE_SUMMARY_PROVIDER_NAMES,
-): Promise<{ provider: ReleaseSummaryProvider["name"]; summary: string } | undefined> {
-  for (const name of providers) {
-    const provider = RELEASE_SUMMARY_PROVIDERS.find((candidate) => candidate.name === name);
-    if (!provider) continue;
-    const summary = (await runner(provider, root, prompt))?.trim();
-    if (summary) return { provider: provider.name, summary };
-  }
-  return undefined;
-}
-
-function summaryPrompt(
-  projectName: string,
-  version: string,
-  fromRef: string | undefined,
-  commits: string,
-  changedFiles: string,
-  diffStat: string,
-): string {
-  return [
-    `Write a concise user-facing Markdown release summary for ${projectName} ${version}.`,
-    "Use only the supplied Git context. Do not run commands, edit files, speculate,",
-    "mention commit hashes, use emojis, or use em/en dashes.",
-    "Return no title and no fenced block. Start with one short paragraph, then",
-    "group concrete changes under brief Markdown headings with bullets.",
-    "",
-    `Comparison base: ${fromRef ?? "repository root"}`,
-    "",
-    "Commits:",
-    commits || "(none)",
-    "",
-    "Changed files:",
-    changedFiles || "(none)",
-    "",
-    "Diff stat:",
-    diffStat || "(none)",
-  ].join("\n");
-}
-
-/** Deterministic fallback when every configured AI provider is unavailable. */
-function gitSummary(
-  projectName: string,
-  version: string,
-  commits: string,
-  changedFiles: string,
-): string {
-  const subjects = commits
-    .split("\n")
-    .map((line) => line.trim())
-    .filter(Boolean)
-    .filter((line, index, lines) => lines.indexOf(line) === index)
-    .slice(0, 20);
-  const files = changedFiles
-    .split("\n")
-    .map((line) => line.trim().split(/\s+/).at(-1))
-    .filter((value): value is string => Boolean(value));
-  const areas = files
-    .map((file) => {
-      if (file.startsWith("packages/")) return file.split("/").slice(0, 4).join("/");
-      return file.split("/")[0] ?? file;
-    })
-    .filter((area, index, all) => all.indexOf(area) === index)
-    .slice(0, 12);
-  const bullets = subjects.length ? subjects : areas.map((area) => `Updated ${area}`);
-  return [
-    `${projectName} ${version} contains the reviewed changes listed below.`,
-    "",
-    "## Changes",
-    ...(bullets.length ? bullets.map((item) => `- ${item}`) : ["- Release metadata updated."]),
-  ].join("\n");
-}
-
-/** Generate one immutable versioned summary with an AI or Git fallback. */
-export async function generateReleaseSummary(options: {
-  readonly root: string;
-  readonly version: string;
-  readonly component?: string;
-  readonly paths?: readonly string[];
-  readonly customSummary?: string;
-  readonly outputFile?: string;
-  readonly fromRef?: string;
-  readonly toRef?: string;
-  readonly providers?: readonly ReleaseSummaryProviderName[];
-  readonly runner?: ReleaseSummaryRunner;
-}): Promise<string | undefined> {
-  const projectName = projectUtils.name(options.root);
-  const relativeOutput =
-    options.outputFile ?? releaseSummaryFile(options.version, options.component);
-  const output = join(options.root, relativeOutput);
-  if (existsSync(output)) rmSync(output);
-  const target =
-    options.toRef &&
-    captureTaskCommand(options.root, "git", ["rev-parse", "--verify", options.toRef])
-      ? options.toRef
-      : "HEAD";
-  const range =
-    options.fromRef &&
-    captureTaskCommand(options.root, "git", ["rev-parse", "--verify", options.fromRef])
-      ? `${options.fromRef}..${target}`
-      : target;
-  const scopedPaths = options.paths?.length ? [...options.paths] : ["."];
-  const commits = captureTaskCommand(options.root, "git", [
-    "log",
-    "--no-merges",
-    "--format=%s%n%b",
-    range,
-    "--",
-    ...scopedPaths,
-  ]);
-  const changedFiles = captureTaskCommand(options.root, "git", [
-    "diff",
-    "--name-status",
-    range,
-    "--",
-    ...scopedPaths,
-    `:(exclude)${relativeOutput}`,
-  ]);
-  const diffStat = captureTaskCommand(options.root, "git", [
-    "diff",
-    "--stat",
-    range,
-    "--",
-    ...scopedPaths,
-    `:(exclude)${relativeOutput}`,
-  ]);
-  const customSummary = stringUtils.trimToNull(options.customSummary);
-  const result = customSummary
-    ? undefined
-    : await selectReleaseSummary(
-        options.root,
-        summaryPrompt(
-          projectName,
-          options.version,
-          options.fromRef,
-          commits,
-          changedFiles,
-          diffStat,
-        ),
-        options.runner,
-        options.providers,
-      );
-  const summary =
-    customSummary ??
-    result?.summary ??
-    gitSummary(projectName, options.version, commits, changedFiles);
-  const provider = customSummary ? "custom" : (result?.provider ?? "git");
-  if (!customSummary && !result) {
-    logger.info("AI providers unavailable; using Git release summary");
-  }
-  const content = `# Release ${options.component ? `${options.component} ` : ""}${options.version}\n\n${summary.trim()}\n`;
-  mkdirSync(dirname(output), { recursive: true });
-  writeFileSync(output, content);
-  logger.info("generated", { provider, path: output });
-  return content;
-}

package/tasks/rust.ts

@@ -1,173 +0,0 @@
-#!/usr/bin/env -S bun
-import { existsSync } from "node:fs";
-import { dirname, isAbsolute, resolve, sep } from "node:path";
-import { fileURLToPath } from "node:url";
-import { log, object } from "@dbx-tools/shared-core";
-import { runTaskCommand, taskCommandSucceeds } from "../src/_task-command.ts";
-import { readDbxToolsConfig, repoRoot } from "../src/packages.ts";
-import {
-  discoverRustCrates,
-  hasUniFFIBindings,
-  orderRustBindings,
-  type RustBindingMapping,
-  type RustWorkspaceMapping,
-} from "../src/project-rs.ts";
-import { runSynth } from "../src/scaffold.ts";
-import { watchLoop } from "../src/watch.ts";
-
-const logger = log.logger("projen:rust");
-
-function rustConfig(): RustWorkspaceMapping | undefined {
-  const value = readDbxToolsConfig(repoRoot)?.rust;
-  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
-  const candidate = value as Partial<RustWorkspaceMapping>;
-  if (typeof candidate.root !== "string") return undefined;
-  if (!Array.isArray(candidate.crates) || !Array.isArray(candidate.bindings)) return undefined;
-  return candidate as RustWorkspaceMapping;
-}
-
-function cargoAvailable(): boolean {
-  return taskCommandSucceeds(repoRoot, "cargo", ["--version"]);
-}
-
-function currentStructure(config: RustWorkspaceMapping): RustWorkspaceMapping {
-  const root = resolve(repoRoot, config.root);
-  const directories = discoverRustCrates(root);
-  const crates = directories.map((directory) => `${config.root}/${directory}`);
-  const recorded = new Map(config.bindings.map((binding) => [binding.rust, binding]));
-  const bindings = crates.flatMap((rust) => {
-    if (!hasUniFFIBindings(resolve(repoRoot, rust))) return [];
-    const binding = recorded.get(rust);
-    return binding ? [binding] : [{ crate: "", rust }];
-  });
-  return { ...config, crates, bindings };
-}
-
-/** Whether discovered crate membership or UniFFI marker membership changed. */
-export function rustStructureChanged(config: RustWorkspaceMapping): boolean {
-  return !sameStructure(config, currentStructure(config));
-}
-
-function sameStructure(left: RustWorkspaceMapping, right: RustWorkspaceMapping): boolean {
-  return (
-    JSON.stringify(left.crates) === JSON.stringify(right.crates) &&
-    JSON.stringify(left.bindings.map((binding) => binding.rust)) ===
-      JSON.stringify(right.bindings.map((binding) => binding.rust))
-  );
-}
-
-function ownerBinding(
-  path: string,
-  bindings: readonly RustBindingMapping[],
-): RustBindingMapping | undefined {
-  const absolute = isAbsolute(path) ? path : resolve(repoRoot, path);
-  return bindings.find((binding) => {
-    const directory = resolve(repoRoot, binding.rust);
-    return absolute === directory || absolute.startsWith(directory + sep);
-  });
-}
-
-function generate(binding: RustBindingMapping): void {
-  const targets = [
-    ...(binding.node ? ["--node", binding.node] : []),
-    ...(binding.python
-      ? ["--python", binding.python, "--python-module", binding.pythonModule ?? ""]
-      : []),
-  ];
-  runTaskCommand(repoRoot, process.execPath, [
-    resolve(dirname(fileURLToPath(import.meta.url)), "uniffi.ts"),
-    "--crate",
-    binding.crate,
-    ...targets,
-  ]);
-}
-
-function* iterateAffectedRustBindings(
-  bindings: readonly RustBindingMapping[],
-  changed: ReadonlySet<string>,
-): Generator<RustBindingMapping> {
-  const affected = new Set(changed);
-  for (const binding of orderRustBindings(bindings)) {
-    if (binding.dependencies?.some((dependency) => affected.has(dependency))) {
-      affected.add(binding.crate);
-    }
-    if (affected.has(binding.crate)) yield binding;
-  }
-}
-
-export function affectedRustBindings(
-  bindings: readonly RustBindingMapping[],
-  changed: ReadonlySet<string>,
-): RustBindingMapping[] {
-  return [...iterateAffectedRustBindings(bindings, changed)];
-}
-
-/**
- * Lazily resolve direct binding owners so lock checks stop at the first match.
- */
-export function changedRustOwners(
-  config: RustWorkspaceMapping,
-  changed: readonly string[],
-): object.Sequence<RustBindingMapping> {
-  return object
-    .sequence(changed)
-    .map((path) => ownerBinding(path, config.bindings))
-    .nonNull()
-    .distinct();
-}
-
-/** Collect direct owners, then lazily yield them and their dependents in order. */
-export function changedRustBindings(
-  config: RustWorkspaceMapping,
-  changed: readonly string[],
-): object.Sequence<RustBindingMapping> {
-  const targets = new Set(changedRustOwners(config, changed).map((binding) => binding.crate));
-  return object.sequence(iterateAffectedRustBindings(config.bindings, targets));
-}
-
-const config = rustConfig();
-
-async function main(): Promise<void> {
-  if (!config || config.crates.length === 0 || !existsSync(resolve(repoRoot, config.root))) return;
-  if (!cargoAvailable()) {
-    throw new Error("Cargo is required because Rust projects were detected");
-  }
-  if (!process.argv.includes("--watch")) {
-    for (const binding of orderRustBindings(config.bindings)) generate(binding);
-    return;
-  }
-
-  watchLoop(
-    "rust",
-    [resolve(repoRoot, config.root)],
-    (changed) => {
-      const latest = rustConfig() ?? config;
-      if (rustStructureChanged(latest)) {
-        logger.start("Rust project structure changed - re-synthesizing (+install)");
-        runSynth({ post: true });
-        logger.success("Rust project structure synchronized");
-        const refreshed = rustConfig();
-        if (!refreshed) return;
-        for (const binding of changedRustBindings(refreshed, changed)) {
-          logger.start(`generating ${binding.crate} bindings`);
-          generate(binding);
-          logger.success(`generated ${binding.crate} bindings`);
-        }
-        return;
-      }
-      for (const binding of changedRustBindings(latest, changed)) {
-        logger.start(`generating ${binding.crate} bindings`);
-        generate(binding);
-        logger.success(`generated ${binding.crate} bindings`);
-      }
-    },
-    {
-      check: (changed) => {
-        const latest = rustConfig() ?? config;
-        return changedRustOwners(latest, changed).some(() => true) || rustStructureChanged(latest);
-      },
-    },
-  );
-}
-
-if (import.meta.main) await main();

package/tasks/uniffi-python.d.ts

@@ -1,60 +0,0 @@
-export interface TomlCodec {
-  parse(source: string): unknown;
-  stringify(document: unknown): string;
-}
-
-export interface PythonPackageMapping {
-  readonly directory: string;
-  readonly name: string;
-  readonly version: string;
-  readonly uniffi: boolean;
-}
-
-export interface PythonProjectInfo {
-  readonly name: string;
-  readonly version: string;
-  readonly private: boolean;
-  readonly uniffi: boolean;
-}
-
-/** Read the project identity and publication flag from parsed TOML metadata. */
-export function pythonProjectInfo(source: string, toml: TomlCodec): PythonProjectInfo;
-
-/** Project registry-compatible sibling requirements onto a temporary package copy. */
-export function preparePythonProjectForPublication(
-  source: string,
-  options: {
-    readonly packages: readonly PythonPackageMapping[];
-    readonly rewriteDependencies?: boolean;
-    readonly toml: TomlCodec;
-    readonly version: string;
-  },
-): string;
-
-/** Return the target-specific UniFFI generator executable name. */
-export function pythonBindingGeneratorName(crate: string, platform: string): string;
-
-/** Build the canonical UniFFI Python generator argument list. */
-export function pythonBindingGeneratorArgs(options: {
-  readonly crate: string;
-  readonly library: string;
-  readonly output: string;
-}): string[];
-
-export interface InstalledPythonBindings {
-  readonly bindings: string;
-  readonly init: string;
-  readonly library: string;
-}
-
-/** Generate and place one Python binding module and its native library. */
-export function installPythonBindings(options: {
-  readonly crate: string;
-  readonly library: string;
-  readonly module: string;
-  readonly packageRoot: string;
-  readonly platform: string;
-  readonly readonly?: boolean;
-  readonly run: (command: string, args: string[]) => void;
-  readonly targetDirectory: string;
-}): InstalledPythonBindings;