@modulify/conventional-release 0.1.0

package/dist/plan.d.ts

@@ -0,0 +1,24 @@
+import { Mode, Options, Package, Range, Scope, ScopePackage, Slice, SliceMode } from '../types/index';
+import { Runtime } from './runtime';
+export type DiscoveredSlice = {
+    id: string;
+    kind: Slice['kind'];
+    mode: SliceMode;
+    partition?: string;
+    packages: Package[];
+    range: Range;
+};
+export type DiscoveredScope = {
+    mode: Mode;
+    packages: Package[];
+    affected: Package[];
+    slices: DiscoveredSlice[];
+};
+export declare function toScope(scope: DiscoveredScope, cwd: string): Scope;
+/** Discovers packages, affected scope, and ordered release slices without side effects. */
+export declare function discover(runtime: Runtime, options: Options): Promise<DiscoveredScope>;
+export declare function toScopePackage(pkg: Package, cwd: string): ScopePackage;
+export declare function toSlice(slice: DiscoveredSlice, cwd: string): Slice;
+export declare function uniquePackages(packages: Package[]): Package[];
+export declare function uniqueStrings(values: string[]): string[];
+export declare function packageIdentity(pkg: Package, cwd: string): string;

package/dist/reporter.d.ts

@@ -0,0 +1,11 @@
+import { Reporter, Result, RunContext, Scope, Slice, SliceResult } from '../types/index';
+export declare function createRunContext({ cwd, dry, }: {
+    cwd: string;
+    dry: boolean;
+}): RunContext;
+export declare function reportStart(reporter: Reporter | undefined, context: RunContext): Promise<void>;
+export declare function reportScope(reporter: Reporter | undefined, scope: Scope, context: RunContext): Promise<void>;
+export declare function reportSliceStart(reporter: Reporter | undefined, slice: Slice, context: RunContext): Promise<void>;
+export declare function reportSliceSuccess(reporter: Reporter | undefined, slice: SliceResult, context: RunContext): Promise<void>;
+export declare function reportSuccess(reporter: Reporter | undefined, result: Result, context: RunContext): Promise<void>;
+export declare function reportError(reporter: Reporter | undefined, error: unknown, context: RunContext): Promise<void>;

package/dist/runtime.d.ts

@@ -0,0 +1,36 @@
+import { Client as HistoryClient } from '@modulify/conventional-git';
+export type Shell = {
+    exec(command: string, args?: string[]): Promise<unknown>;
+};
+export type Git = {
+    add(files: string[]): Promise<unknown>;
+    commit(options: {
+        files: string[];
+        message: string;
+    }): Promise<unknown>;
+    tag(options: {
+        name: string;
+        message: string;
+    }): Promise<unknown>;
+};
+export type PackageManagerName = 'yarn' | 'pnpm' | 'npm' | 'bun';
+export interface PackageManager {
+    command: PackageManagerName;
+    lockfile: string;
+}
+export interface Runtime {
+    cwd: string;
+    dry: boolean;
+    changelogFile: string;
+    packageManager: PackageManager;
+    history: Pick<HistoryClient, 'traverse' | 'url'>;
+    writeChangelog(changes: string): Promise<string>;
+    sh: Shell;
+    git: Git;
+}
+/** Creates the default runtime used by the public planning and release APIs. */
+export declare function createRuntime({ cwd, dry, changelogFile, }?: {
+    cwd?: string;
+    dry?: boolean;
+    changelogFile?: string;
+}): Runtime;

package/package.json

@@ -0,0 +1,98 @@
+{
+  "name": "@modulify/conventional-release",
+  "type": "module",
+  "version": "0.1.0",
+  "license": "ISC",
+  "homepage": "https://github.com/modulify/conventional/tree/main/packages/conventional-release#readme",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.mjs"
+    },
+    "./types": {
+      "types": "./types/index.d.ts",
+      "default": "./types/index.d.ts"
+    },
+    "./types/*": {
+      "types": "./types/*.d.ts",
+      "default": "./types/*.d.ts"
+    }
+  },
+  "types": "dist/index.d.ts",
+  "bin": "./bin/index.js",
+  "peerDependencies": {
+    "@types/node": ">=20",
+    "@types/semver": "^7.7.1"
+  },
+  "peerDependenciesMeta": {
+    "@types/node": {
+      "optional": true
+    },
+    "@types/semver": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@modulify/conventional-bump": "^0.1.0",
+    "@modulify/conventional-changelog": "^0.1.0",
+    "@modulify/conventional-git": "^0.1.0",
+    "@modulify/git-toolkit": "^0.0.2",
+    "@modulify/pkg": "^1.0.1",
+    "chalk": "^5.6.2",
+    "figures": "^6.1.0",
+    "semver": "^7.7.3",
+    "yargs": "^17.7.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.18.6",
+    "@types/semver": "^7.7.1",
+    "@types/yargs": "^17.0.35",
+    "tslib": "^2.8.1",
+    "typescript": "^5.9.3",
+    "vite": "^7.3.0",
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^4.0.16"
+  },
+  "author": {
+    "name": "modulify",
+    "email": "https://github.com/modulify"
+  },
+  "contributors": [
+    {
+      "name": "Zaitsev Kirill",
+      "email": "zaytsev.cmath10@gmail.com"
+    },
+    {
+      "name": "conventional-changelog team",
+      "url": "https://github.com/conventional-changelog"
+    }
+  ],
+  "keywords": [
+    "conventional",
+    "git",
+    "release"
+  ],
+  "files": [
+    "bin/*.cjs",
+    "bin/*.js",
+    "bin/*.mjs",
+    "dist/*.cjs",
+    "dist/*.mjs",
+    "dist/*.d.ts",
+    "types/*.d.ts",
+    "LICENSE.md",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "node ./scripts/build-cli.mjs --prepare && vite build && node ./scripts/build-cli.mjs",
+    "typecheck": "tsc -b tsconfig.typecheck.json"
+  }
+}

package/types/domain.d.ts

@@ -0,0 +1,124 @@
+import type { Manifest } from '@modulify/pkg/types/manifest'
+
+export type { Manifest }
+
+/** Package node discovered in the release scope. */
+export type Package = {
+  /** Package name from `package.json` when available. */
+  name?: string
+  /** Absolute filesystem path to the package root. */
+  path: string
+  /** Parsed package manifest. */
+  manifest: Manifest
+  /** Nested workspace packages discovered under this package. */
+  children: Package[]
+}
+
+/** Release coordination strategy for the selected repository scope. */
+export type Mode = 'sync' | 'async' | 'hybrid'
+/** Execution mode for a single slice. */
+export type SliceMode = 'sync' | 'async'
+/** Semantic kind of slice in the public scope/result model. */
+export type SliceKind = 'sync' | 'async' | 'partition'
+
+/** Git advisory range used to calculate the next version for a step. */
+export interface Range {
+  /** Explicit lower tag bound for commit analysis. */
+  fromTag?: string
+  /** Prefix or pattern used to match release tags. */
+  tagPrefix?: string | RegExp
+}
+
+/** Workspace selection filters applied during package discovery. */
+export type WorkspaceSelector = {
+  /** Workspace names or paths to include. */
+  include?: string[]
+  /** Workspace names or paths to exclude after inclusion. */
+  exclude?: string[]
+}
+
+/** Named workspace partition participating in hybrid scope discovery. */
+export type Partition = Range & {
+  /** Execution mode for workspaces matched by this partition. */
+  mode: SliceMode
+  /** Workspace selectors belonging to the partition. */
+  workspaces: string[]
+}
+
+/** Public package descriptor returned from scopes and results. */
+export type ScopePackage = {
+  /** Package name from `package.json` when available. */
+  name?: string
+  /** The current package version when available. */
+  version?: string
+  /** Package path relative to the release root. */
+  path: string
+}
+
+/** Single slice in a computed scope. */
+export interface Slice {
+  /** Stable identifier for the slice. */
+  id: string
+  /** High-level semantic kind of the slice. */
+  kind: SliceKind
+  /** Execution mode used for the slice. */
+  mode: SliceMode
+  /** Partition name for hybrid partition slices. */
+  partition?: string
+  /** Packages participating in the slice. */
+  packages: ScopePackage[]
+  /** Git advisory range used for version calculation. */
+  range: Range
+}
+
+/** Deterministic release scope produced before side effects are applied. */
+export interface Scope {
+  /** Global release mode used for discovery. */
+  mode: Mode
+  /** All packages in the resolved release scope. */
+  packages: ScopePackage[]
+  /** Packages affected by the current working tree state. */
+  affected: ScopePackage[]
+  /** Ordered release slices to execute. */
+  slices: Slice[]
+}
+
+/** Result of applying a single release slice. */
+export interface SliceResult extends Slice {
+  /** Version used as the starting point for the slice. */
+  currentVersion: string
+  /** Version produced for the slice. */
+  nextVersion: string
+  /** Semantic release type reported by the advisor. */
+  releaseType: string
+  /** Whether the slice produced a version change. */
+  changed: boolean
+  /** Whether the slice ran in dry-run mode. */
+  dry: boolean
+  /** Files touched or planned for the slice. */
+  files: string[]
+  /** Tag created or planned for the slice. */
+  tag?: string
+  /** Commit message created or planned for the slice. */
+  commitMessage?: string
+  /** Annotated tag message created or planned for the slice. */
+  tagMessage?: string
+}
+
+/** Aggregated result of executing all release slices. */
+export interface Result {
+  /** Global release mode used for execution. */
+  mode: Mode
+  /** Whether at least one slice produced a version change. */
+  changed: boolean
+  /** Whether the release ran in dry-run mode. */
+  dry: boolean
+  /** All packages in the resolved release scope. */
+  packages: ScopePackage[]
+  /** Packages affected by the current working tree state. */
+  affected: ScopePackage[]
+  /** Per-slice execution results. */
+  slices: SliceResult[]
+  /** Union of files touched across all changed slices. */
+  files: string[]
+}

package/types/index.d.ts

@@ -0,0 +1,23 @@
+export type {
+  Mode,
+  Partition,
+  Package,
+  Scope,
+  ScopePackage,
+  Range,
+  Result,
+  Slice,
+  SliceKind,
+  SliceMode,
+  SliceResult,
+  WorkspaceSelector,
+  Manifest,
+} from './domain'
+
+export type {
+  Options,
+  Reporter,
+  RunContext,
+  RunOptions,
+  TagContext,
+} from './release'

package/types/release.d.ts

@@ -0,0 +1,93 @@
+import type { ReleaseType as SemverReleaseType } from 'semver'
+
+import type {
+  Partition,
+  Mode,
+  Result,
+  Scope,
+  ScopePackage,
+  Range,
+  Slice,
+  SliceKind,
+  SliceMode,
+  SliceResult,
+  WorkspaceSelector,
+} from './domain'
+
+/** Context object passed to tag and message formatters. */
+export interface TagContext {
+  /** Stable identifier of the current release slice. */
+  id: string
+  /** Semantic kind of the current slice. */
+  kind: SliceKind
+  /** Execution mode of the current slice. */
+  mode: SliceMode
+  /** Partition name for hybrid partition slices. */
+  partition?: string
+  /** Packages participating in the current slice. */
+  packages: ScopePackage[]
+  /** Semantic release type produced by the advisor. */
+  releaseType: string
+  /** Version produced for the current slice. */
+  version: string
+}
+
+/** Invocation context passed to reporter hooks. */
+export interface RunContext {
+  /** Working directory used as the release root. */
+  cwd: string
+  /** Whether side effects are skipped. */
+  dry: boolean
+}
+
+/** Lifecycle reporter used during `run(...)` execution. */
+export interface Reporter {
+  /** Called before config resolution and scope discovery begin. */
+  onStart?(context: RunContext): void | Promise<void>
+  /** Called after the public scope has been resolved. */
+  onScope?(scope: Scope, context: RunContext): void | Promise<void>
+  /** Called before a slice starts execution. */
+  onSliceStart?(slice: Slice, context: RunContext): void | Promise<void>
+  /** Called after a slice has completed execution. */
+  onSliceSuccess?(slice: SliceResult, context: RunContext): void | Promise<void>
+  /** Called after the full release has completed successfully. */
+  onSuccess?(result: Result, context: RunContext): void | Promise<void>
+  /** Called when `run(...)` exits with an error. */
+  onError?(error: unknown, context: RunContext): void | Promise<void>
+}
+
+/** High-level options accepted by the release planner and executor. */
+export interface Options extends Range {
+  /** Global release strategy for the selected repository scope. */
+  mode?: Mode
+  /** Explicit semantic release type override. */
+  releaseAs?: SemverReleaseType
+  /** Prerelease channel used when generating prerelease versions. */
+  prerelease?: 'alpha' | 'beta' | 'rc'
+  /** Whether dependency installation should run after manifest updates, or extra arguments appended after the installation subcommand. */
+  install?: boolean | string[]
+  /** Workspace discovery filters. */
+  workspaces?: WorkspaceSelector
+  /** Named hybrid partitions for mixed sync/async discovery. */
+  partitions?: Record<string, Partition>
+  /** Range style applied to bumped internal dependencies. */
+  dependencyPolicy?: 'preserve' | 'caret' | 'exact'
+  /** Custom tag name formatter. */
+  tagName?: (context: TagContext) => string
+  /** Custom annotated tag message formatter. */
+  tagMessage?: (context: TagContext & { tag: string; }) => string
+  /** Custom commit message formatter. */
+  commitMessage?: (context: TagContext & { tag: string; }) => string
+  /** Changelog file path relative to the repository root. */
+  changelogFile?: string
+}
+
+/** High-level options accepted by the public planning and execution APIs. */
+export interface RunOptions extends Options {
+  /** Working directory used as the release root. */
+  cwd?: string
+  /** Whether side effects should be skipped. */
+  dry?: boolean
+  /** Optional lifecycle reporter for run-time progress and summaries. */
+  reporter?: Reporter
+}