@qlover/fe-release 4.3.1 → 5.0.2

package/dist/index.d.ts

@@ -1,683 +1,1483 @@
-import { LifecycleExecutor, ExecutorContextInterface } from '@qlover/fe-corekit';
-import { ScriptPlugin, ScriptContext, ScriptPluginProps, ScriptSharedInterface, ScriptContextInterface, FeReleaseConfig, ShellInterface } from '@qlover/scripts-context';
+import { ExecutorContextInterface, LifecycleExecutor } from '@qlover/fe-corekit';
+import { ScriptPluginProps, ScriptPlugin, ScriptSharedInterface, ScriptContextInterface, ScriptContext, TemplateEngine, RenderFn, ShellInterface } from '@qlover/scripts-context';
 export { ScriptPlugin } from '@qlover/scripts-context';
 import { CommitField } from 'gitlog';
 import { LoggerInterface } from '@qlover/logger';
 import { OptionValues } from 'commander';
 
 /**
- * @module PluginTuple
- * @description Type-safe plugin tuple creation and handling
- *
- * This module provides utilities for creating and handling tuples that
- * represent plugin configurations. It ensures type safety when working
- * with plugin constructors and their parameters.
- *
- * Core Features:
- * - Type-safe plugin class handling
- * - Constructor parameter inference
- * - Plugin tuple creation
- *
- * @example Basic usage
- * ```typescript
- * class MyPlugin extends ScriptPlugin {
- *   constructor(context: ScriptContext, config: { option: string }) {
- *     super(context);
- *   }
- * }
+ * @module WorkspaceInterface
+ * @description Core data model for a monorepo package in a release run
  *
- * const pluginTuple = tuple(MyPlugin, { option: 'value' });
- * // [MyPlugin, { option: 'value' }]
- * ```
+ * Represents one publishable workspace discovered by the {@link Workspaces}
+ * plugin and passed through {@link ChangesetVersion} and {@link Github}.
  *
- * @example Plugin name string
- * ```typescript
- * const pluginTuple = tuple('MyPlugin', { option: 'value' });
- * // ['MyPlugin', { option: 'value' }]
- * ```
+ * Typical lifecycle fields:
+ * - `version` / `newVersion` — before and after `changeset version`
+ * - `lastTag` — git baseline for changelog generation
+ * - `dependencyRelease` — internal dependent bumped only because a dependency changed
  */
 
+interface WorkspaceInterface {
+    /**
+     * Package name from package.json
+     */
+    name: string;
+    /**
+     * Current version from package.json before bump
+     */
+    version: string;
+    /**
+     * Version after `changeset version`, read from package.json on disk.
+     *
+     * - Before bump: usually undefined
+     * - After bump: latest version on disk; may equal `version` if unchanged
+     */
+    newVersion?: string;
+    /**
+     * The relative path of the workspace
+     */
+    path: string;
+    /**
+     * The absolute path of the workspace
+     */
+    root: string;
+    /**
+     * The package.json of the workspace
+     */
+    packageJson: PackageJson;
+    /**
+     * Release tag name after version bump (for example `pkg@1.0.1`).
+     *
+     * Set by ChangesetVersion.mergeWorkspaces only when `newVersion` differs
+     * from `version`. Not available before `changeset version` completes.
+     */
+    tagName?: string;
+    /**
+     * Previous release tag used as the git changelog baseline
+     */
+    lastTag?: string;
+    /**
+     * The changelog of the workspace
+     *
+     */
+    changelog?: string;
+    /**
+     * Whether this workspace is an internal dependent bumped only because a
+     * dependency was released (not directly changed in git).
+     *
+     * Set by the Workspaces plugin when `includeDependencyReleases` is enabled.
+     * Processing rules depend on `changesetVersion.ignoreNonUpdatedPackages`:
+     *
+     * - `false`: included in changelog template flow and version bump logs
+     * - `true`: tracked for restore only; skipped in changelog generation
+     *
+     * @default false
+     */
+    dependencyRelease?: boolean;
+    /**
+     * Package name of the direct dependency that caused this `dependencyRelease`.
+     *
+     * Set by Workspaces when appending dependents. ChangesetVersion uses it after
+     * `changeset version` to fill `dependencyReleaseTemplate` with the source's
+     * real `newVersion`.
+     */
+    dependencyReleaseOf?: string;
+}
+
 /**
- * Plugin class constructor type
- *
- * Represents a constructor for a class that extends ScriptPlugin.
- * Supports generic constructor arguments.
+ * Base configuration for Git-related plugins
  *
- * @template T - Array type for constructor arguments
+ * Extends ScriptPluginProps with generic options.
  *
  * @example
  * ```typescript
- * class MyPlugin extends ScriptPlugin {
- *   constructor(context: ScriptContext, config: { option: string }) {
- *     super(context);
- *   }
- * }
- *
- * const PluginCtor: PluginClass = MyPlugin;
+ * const config: GitBaseProps = {
+ *   timeout: 5000
+ * };
  * ```
  */
-type PluginClass<T extends unknown[] = any[]> = new (...args: T) => ScriptPlugin<ScriptContext<any>, ScriptPluginProps>;
+interface GitBaseProps extends ScriptPluginProps {
+    /**
+     * Environment variable name for GitHub API token
+     * @deprecated This property is GitHub-specific, use a subclass if needed.
+     */
+    tokenRef?: string;
+    /**
+     * Timeout for API requests in milliseconds (generic)
+     */
+    timeout?: number;
+}
+
 /**
- * Plugin constructor parameters type
+ * @module ReleaseFormatter
+ * @description Template-based formatting for release branches, commits, and PRs
  *
- * Extracts the constructor parameter types for a plugin class,
- * excluding the first parameter (context). Uses TypeScript's
- * conditional types and inference to extract parameter types.
+ * Centralizes string formatting for the GitHub release flow. Uses
+ * {@link TemplateEngine} from `@qlover/scripts-context` with ES6-style
+ * `${ path }` placeholders and variables from {@link BranchNameTplVars}.
  *
- * @template T - Plugin class type
+ * Responsibilities:
+ * - **Branch/tag names**: `getReleaseBranch()` from `branchName` / `releaseTagName` templates
+ * - **Commit message**: `getCommitMessage()` with optional `less` / `more` templates when
+ *   workspace count exceeds 3
+ * - **PR content**: `getPRTitle()` and `getPRBody()` with single- vs multi-workspace changelog
+ *   formatting via `batchPRBody`
  *
- * @example
- * ```typescript
- * class MyPlugin extends ScriptPlugin {
- *   constructor(
- *     context: ScriptContext,
- *     config: { option: string },
- *     extra: number
- *   ) {
- *     super(context);
- *   }
- * }
+ * Defaults are sourced from `releaseJson.github` in {@link defaults}.
+ * {@link Github} constructs an instance and calls `setConfig()` in `onBefore`
+ * with runtime context (`repoName`, `releaseId`, `env`, etc.).
  *
- * // Type: [{ option: string }, number]
- * type Params = PluginConstructorParams<typeof MyPlugin>;
+ * @example Branch name template variables
+ * ```typescript
+ * // Template: release/${repoName}-${releaseId}
+ * // Variables: repoName, releaseId, timestamp, authorName, env, count, spaces
+ * formatter.getReleaseBranch(workspaces);
  * ```
- */
-type PluginConstructorParams<T extends PluginClass> = T extends new (first: any, ...args: infer P) => unknown ? P : never;
-/**
- * Plugin configuration tuple type
  *
- * Represents a tuple containing a plugin class (or name) and its
- * constructor arguments. Used for plugin registration and loading.
- *
- * @template T - Plugin class type
- *
- * @example
+ * @example Multi-workspace PR body
  * ```typescript
- * class MyPlugin extends ScriptPlugin {
- *   constructor(context: ScriptContext, config: { option: string }) {
- *     super(context);
- *   }
- * }
- *
- * // Type: [typeof MyPlugin, { option: string }]
- * type Tuple = PluginTuple<typeof MyPlugin>;
- *
- * // Type: [string, { option: string }]
- * type StringTuple = PluginTuple<'MyPlugin'>;
+ * formatter.getPRBody(workspaces, releaseBranchResult, templateContext);
  * ```
  */
-type PluginTuple<T extends PluginClass> = [
-    T | string,
-    ...PluginConstructorParams<T>
-];
+
+interface ReleaseFormatterConfig {
+    /**
+     * Repository name
+     */
+    repoName?: string;
+    /**
+     * Author name
+     */
+    authorName?: string;
+    /**
+     * Release environment
+     */
+    env?: string;
+    /**
+     * Unique ID for the current release run
+     */
+    releaseId?: string;
+    /**
+     * The branch name for batch release
+     *
+     * Template variables: see {@link BranchNameTplVars}
+     *
+     * @default `release/${repoName}-${releaseId}`
+     */
+    branchName?: string;
+    /**
+     * The tag name for batch release
+     *
+     * Template variables: see {@link BranchNameTplVars}
+     *
+     * @default `release-tag-${count}-patch-${releaseId}`
+     */
+    releaseTagName?: string;
+    /**
+     *
+     * @default 'Release ${spaces}' */
+    releaseName?: string;
+    /**
+     * Commit message template used when creating the release branch
+     *
+     * When configured as an object, supports `less` and `more` templates:
+     * - `less`: used when workspace count is 3 or fewer
+     * - `more`: used when workspace count exceeds 3
+     *
+     * Supports conventional commit structure: subject, body, and footer.
+     *
+     * **Object form is experimental.**
+     *
+     * @example Conventional commit layout
+     * ```
+     * <type>(<scope>): <subject>    <-- Header/Subject (required)
+     *                               <-- blank line
+     * <body>                        <-- detailed description (optional)
+     *                               <-- blank line
+     * <footer>                      <-- issue refs or BREAKING CHANGE (optional)
+     * ```
+     *
+     * @example Full template string
+     *
+     * ```
+     * \`\`\`
+     * chore(release): bump ${worksapce[0].name} to v${worksapce[0].newVersion} and others
+     *   -
+     * \`\`\`
+     * ```
+     *
+     * By default, lists all package names and versions in the commit message.
+     *
+     * @default `'chore(release): ${spaces}'`
+     */
+    commitMessage?: string | {
+        less: string;
+        more: string;
+    };
+    /**
+     * Pull request title template
+     *
+     * @default {@link DEFAULT_PR_TITLE}
+     */
+    PRTitle?: string;
+    /**
+     * Pull request body template
+     *
+     * @default from release.json
+     */
+    PRBody?: string;
+    /**
+     * Template for each workspace section in a multi-workspace PR body
+     *
+     * @default from release.json
+     */
+    batchPRBody?: string;
+}
+
 /**
- * Creates a type-safe plugin configuration tuple
- *
- * Helper function for creating tuples that represent plugin
- * configurations with proper type inference for constructor
- * arguments.
- *
- * @template T - Plugin class type
- * @param plugin - Plugin class or name
- * @param args - Plugin constructor arguments
- * @returns Plugin configuration tuple
- *
- * @example Class-based plugin
- * ```typescript
- * class MyPlugin extends ScriptPlugin {
- *   constructor(
- *     context: ScriptContext,
- *     config: { option: string },
- *     extra: number
- *   ) {
- *     super(context);
+ * @module Github
+ * @description GitHub changelog enrichment and release PR plugin
+ *
+ * Third plugin in the default release pipeline (after {@link Workspaces} and
+ * {@link ChangesetVersion}). Extends {@link GitBase} for git operations and
+ * delegates GitHub API calls to {@link GithubManager}.
+ *
+ * Pipeline phases:
+ * - **onBefore**: validate GitHub token; seed {@link ReleaseFormatter} context
+ * - **onExec**: enrich workspace changelogs with PR/commit links via {@link GithubChangelog}
+ * - **onSuccess**: create release branch, commit, push, and open PR (unless skipped)
+ *
+ * Release branch flow:
+ * 1. `ReleaseFormatter.getReleaseBranch()` — derive branch and tag names from templates
+ * 2. Create branch from `sourceBranch`, commit version/changelog changes, push
+ * 3. Open PR with formatted title/body and optional labels
+ * 4. Auto-merge when `autoMergeReleasePr` is enabled
+ *
+ * @example Skip PR creation (local dry-run)
+ * ```bash
+ * fe-release --github.skip-create-release-pr --dry-run
+ * ```
+ *
+ * @example fe-config label and merge settings
+ * ```json
+ * {
+ *   "release": {
+ *     "github": {
+ *       "autoMergeReleasePr": false,
+ *       "label": { "name": "CI-Release" }
+ *     }
  *   }
  * }
- *
- * const config = tuple(MyPlugin, { option: 'value' }, 42);
- * // [MyPlugin, { option: 'value' }, 42]
- * ```
- *
- * @example String-based plugin
- * ```typescript
- * const config = tuple('MyPlugin', { option: 'value' });
- * // ['MyPlugin', { option: 'value' }]
  * ```
  */
-declare function tuple<T extends PluginClass>(plugin: T | string, ...args: PluginConstructorParams<T>): PluginTuple<T>;
+
+type GithubMode = 'createPR';
+type GithubLabel = {
+    /**
+     * Hexadecimal color code for label appearance
+     *
+     * Color format: 6-character hex string without '#'
+     * Used for visual distinction in GitHub interface
+     * Supports standard web color codes
+     *
+     * @optional
+     * @default `'1A7F37'`
+     * @example Green color
+     * ```typescript
+     * color: '1A7F37'
+     * ```
+     *
+     * @example Blue color
+     * ```typescript
+     * color: '0366D6'
+     * ```
+     */
+    color?: string;
+    /**
+     * Descriptive text for label documentation
+     *
+     * Provides context about the label's purpose
+     * Used in GitHub label management interface
+     * Helps team members understand label usage
+     *
+     * @optional
+     * @default `'Release PR'`
+     * @example
+     * ```typescript
+     * description: 'Automated release pull request'
+     * ```
+     */
+    description?: string;
+    /**
+     * Label name for identification and display
+     *
+     * Used as the primary identifier for the label
+     * Displayed in GitHub PR interface
+     * Should be descriptive and consistent
+     *
+     * @optional
+     * @default `'CI-Release'`
+     * @example
+     * ```typescript
+     * name: 'release'
+     * ```
+     */
+    name?: string;
+};
+interface GithubProps extends ReleaseFormatterConfig, GitBaseProps {
+    /**
+     * Plugin work mode
+     *
+     * Currently only `createPR` is supported: enrich changelogs in `onExec`,
+     * then create release branch and PR in `onSuccess`.
+     *
+     * @default `'createPR'`
+     */
+    mode?: GithubMode;
+    /**
+     * PR auto-merge strategy for release pull requests
+     *
+     * Core concept:
+     * Defines the merge strategy used when automatically merging
+     * release pull requests, affecting commit history and
+     * repository structure.
+     *
+     * Merge strategies:
+     * - merge: Creates merge commit with branch history
+     * - squash: Combines all commits into single commit
+     * - rebase: Replays commits on target branch
+     *
+     * Strategy considerations:
+     * - merge: Preserves complete branch history
+     * - squash: Creates clean, linear history
+     * - rebase: Maintains chronological order
+     * - Affects commit message and history structure
+     * - Influences repository maintenance and debugging
+     *
+     * @optional
+     * @default `'squash'`
+     * @example Squash merge
+     * ```typescript
+     * const config: FeReleaseConfig = {
+     *   autoMergeType: 'squash'
+     * };
+     * ```
+     *
+     * @example Preserve history
+     * ```typescript
+     * const config: FeReleaseConfig = {
+     *   autoMergeType: 'merge'
+     * };
+     * ```
+     */
+    mergeType?: 'merge' | 'squash' | 'rebase';
+    /**
+     * Whether to skip this plugin
+     * @default false
+     */
+    skip?: boolean;
+    /** @default 'chore(tag): ${name} v${version}' */
+    commitMessage?: string;
+    /** @default [] */
+    commitArgs?: string[];
+    draft?: boolean;
+    preRelease?: boolean;
+    autoGenerate?: boolean;
+    makeLatest?: boolean | 'true' | 'false' | 'legacy';
+    releaseNotes?: string;
+    discussionCategoryName?: string;
+    /**
+     * Whether to auto-merge the created release PR
+     *
+     * @default false
+     */
+    autoMergeReleasePr?: boolean;
+    /** @default false */
+    pushChangeLabels?: boolean;
+    /**
+     * Skip creating the GitHub release pull request.
+     *
+     * When enabled, the release branch is still created and pushed,
+     * but no PR is opened via the GitHub API. Useful for local testing.
+     *
+     * CLI: `--github.skip-create-release-pr`
+     * fe-config: `release.github.skipCreateReleasePR`
+     *
+     * @default false
+     */
+    skipCreateReleasePr?: boolean;
+    /**
+     * Configuration for release pull request labels
+     *
+     * Core concept:
+     * Defines the label configuration for release pull requests,
+     * enabling automated categorization and visual identification
+     * of release-related PRs.
+     *
+     * Label features:
+     * - Automated label application
+     * - Customizable label appearance
+     * - Consistent release identification
+     * - Integration with GitHub labeling system
+     * - Support for custom label descriptions
+     *
+     * Label properties:
+     * - name: Label identifier and display name
+     * - color: Hexadecimal color code for visual distinction
+     * - description: Label description for documentation
+     *
+     * @optional
+     * @example Basic label configuration
+     * ```typescript
+     * const config: FeReleaseConfig = {
+     *   label: {
+     *     name: 'release',
+     *     color: '1A7F37',
+     *     description: 'Automated release PR'
+     *   }
+     * };
+     * ```
+     *
+     * @example Custom label
+     * ```typescript
+     * const config: FeReleaseConfig = {
+     *   label: {
+     *     name: 'CI-Release',
+     *     color: '0366D6',
+     *     description: 'Release created by CI/CD'
+     *   }
+     * };
+     * ```
+     */
+    label?: GithubLabel;
+}
 
 /**
- * @module ReleaseTask
- * @description Task orchestration for release process
- *
- * This module provides the core task orchestration for the release process,
- * managing plugin loading, execution order, and context handling. It serves
- * as the main entry point for executing release operations.
+ * @module ChangeLog
+ * @description Core interfaces for changelog generation
  *
- * Core Features:
- * - Plugin management and execution
- * - Release context initialization
- * - Task execution control
- * - Environment-based control
+ * This module provides the core interfaces and types for generating
+ * changelogs from Git commit history. It includes types for commit
+ * parsing, formatting, and changelog generation.
  *
- * Default Plugins:
- * - Workspaces: Monorepo workspace management
- * - Changelog: Version and changelog management
- * - GithubPR: Pull request creation and management
+ * Core Components:
+ * - Commit data structures
+ * - Changelog formatting
+ * - Git log options
+ * - Changelog generation
  *
  * @example Basic usage
  * ```typescript
- * // Initialize and execute
- * const task = new ReleaseTask({
- *   rootPath: '/path/to/project',
- *   sourceBranch: 'main'
- * });
- *
- * await task.exec();
- * ```
- *
- * @example Custom plugins
- * ```typescript
- * import { tuple } from '@qlover/fe-release';
- *
- * // Add custom plugin
- * class CustomPlugin extends ScriptPlugin {
- *   async onExec() {
- *     // Custom release logic
+ * class MyChangeLog implements ChangeLogInterface {
+ *   async getCommits(options?: GitChangelogOptions): Promise<CommitValue[]> {
+ *     // Implementation
  *   }
  * }
  *
- * const task = new ReleaseTask({}, new LifecycleExecutor<ReleaseContext>(), [
- *   tuple(CustomPlugin, { option: 'value' })
- * ]);
- *
- * await task.exec();
- * ```
- *
- * @example Environment control
- * ```typescript
- * // Skip release
- * process.env.FE_RELEASE = 'false';
- *
- * const task = new ReleaseTask();
- * try {
- *   await task.exec();
- * } catch (e) {
- *   // Handle "Skip Release" error
+ * class MyFormatter implements ChangelogFormatter {
+ *   format(commits: CommitValue[]): string[] {
+ *     // Implementation
+ *   }
  * }
  * ```
  */
 
 /**
- * Core task class for managing release operations
+ * Base commit type mapping Git commit fields
  *
- * Handles plugin orchestration, task execution, and context management
- * for the release process. Supports both built-in and custom plugins.
+ * Maps all available Git commit fields to optional string values.
+ * Uses the CommitField type from gitlog package to ensure type safety.
  *
- * Features:
- * - Plugin lifecycle management
- * - Task execution control
- * - Context initialization and access
- * - Environment-based control
+ * Available fields include:
+ * - hash: Full commit hash
+ * - abbrevHash: Abbreviated commit hash
+ * - subject: Commit message subject
+ * - authorName: Author's name
+ * - authorDate: Author date
+ * - And many more from gitlog.CommitField
  *
- * @example Basic initialization
+ * @example
  * ```typescript
- * const task = new ReleaseTask({
- *   rootPath: '/path/to/project'
- * });
+ * const commit: BaseCommit = {
+ *   hash: 'abc123def456',
+ *   abbrevHash: 'abc123',
+ *   subject: 'feat: new feature',
+ *   authorName: 'John Doe',
+ *   authorDate: '2023-01-01'
+ * };
  * ```
+ */
+type BaseCommit = {
+    [key in CommitField]: string | undefined;
+};
+/**
+ * Configuration options for changelog generation
  *
- * @example Custom executor
- * ```typescript
- * const executor = new LifecycleExecutor<ReleaseContext>({
- *   onError: (err) => console.error('Release failed:', err)
- * });
+ * Provides comprehensive options for controlling how changelogs
+ * are generated from Git history, including commit range selection,
+ * formatting, and filtering.
  *
- * const task = new ReleaseTask({}, executor);
+ * @example Basic usage
+ * ```typescript
+ * const options: GitChangelogOptions = {
+ *   from: 'v1.0.0',
+ *   to: 'v2.0.0',
+ *   directory: 'packages/my-pkg',
+ *   noMerges: true
+ * };
  * ```
  *
- * @example Custom plugins
+ * @example Custom formatting
  * ```typescript
- * const task = new ReleaseTask(
- *   {}, // options
- *   new LifecycleExecutor<ReleaseContext>(),
- *   [
- *     tuple(CustomPlugin, { config: 'value' }),
- *     ...innerTuples // include default plugins
- *   ]
- * );
+ * const options: GitChangelogOptions = {
+ *   types: [
+ *     { type: 'feat', section: '### Features' },
+ *     { type: 'fix', section: '### Bug Fixes' }
+ *   ],
+ *   formatTemplate: '* ${commitlint.message} ${prLink}',
+ *   commitBody: true
+ * };
  * ```
  */
-declare class ReleaseTask {
-    private executor;
-    private defaultTuples;
-    /**
-     * Release context instance
-     * @protected
-     */
-    protected context: ReleaseContext;
+interface GitChangelogOptions {
     /**
-     * Creates a new ReleaseTask instance
-     *
-     * Initializes the release context and sets up plugin configuration.
-     * Supports custom executors and plugin configurations.
+     * Starting tag or commit reference
      *
-     * @param options - Release context configuration
-     * @param executor - Custom async executor (optional)
-     * @param defaultTuples - Plugin configuration tuples (optional)
+     * Defines the start point for collecting commits.
+     * Can be a tag name, commit hash, or branch name.
      *
      * @example
      * ```typescript
-     * // Basic initialization
-     * const task = new ReleaseTask({
-     *   rootPath: '/path/to/project',
-     *   sourceBranch: 'main'
-     * });
-     *
-     * // With custom executor and plugins
-     * const task = new ReleaseTask(
-     *   { rootPath: '/path/to/project' },
-     *   new LifecycleExecutor<ReleaseContext>(),
-     *   [tuple(CustomPlugin, { option: 'value' })]
-     * );
+     * from: 'v1.0.0'  // Start from v1.0.0 tag
+     * from: 'abc123'  // Start from specific commit
      * ```
      */
-    constructor(options?: Partial<ReleaseContextOptions>, executor?: LifecycleExecutor<ReleaseContext>, defaultTuples?: PluginTuple<PluginClass>[]);
+    from?: string;
     /**
-     * Gets the current release context
+     * Ending tag or commit reference
      *
-     * @returns Release context instance
+     * Defines the end point for collecting commits.
+     * Can be a tag name, commit hash, or branch name.
      *
      * @example
      * ```typescript
-     * const task = new ReleaseTask();
-     * const context = task.getContext();
-     *
-     * console.log(context.releaseEnv);
-     * console.log(context.sourceBranch);
+     * to: 'v2.0.0'    // End at v2.0.0 tag
+     * to: 'main'      // End at main branch
      * ```
      */
-    getContext(): ReleaseContext;
+    to?: string;
     /**
-     * Loads and configures plugins for the release task
+     * Directory to collect commits from
      *
-     * Combines default and external plugins, initializes them with
-     * the current context, and configures special cases like the
-     * Workspaces plugin.
+     * Limits commit collection to changes in specified directory.
+     * Useful for monorepo package-specific changelogs.
      *
-     * Plugin Loading Process:
-     * 1. Merge default and external plugins
-     * 2. Initialize plugins with context
-     * 3. Configure special plugins
-     * 4. Add plugins to executor
+     * @example
+     * ```typescript
+     * directory: 'packages/my-pkg'  // Only changes in this directory
+     * ```
+     */
+    directory?: string;
+    /**
+     * Git commit fields to include
      *
-     * @param externalTuples - Additional plugin configurations
-     * @returns Array of initialized plugins
+     * Specifies which Git commit fields to retrieve.
+     * @default ["abbrevHash", "hash", "subject", "authorName", "authorDate"]
      *
-     * @example Basic usage
+     * @example
      * ```typescript
-     * const task = new ReleaseTask();
-     * const plugins = await task.usePlugins();
+     * fields: ['hash', 'subject', 'authorName']
      * ```
+     */
+    fields?: CommitField[];
+    /**
+     * Whether to exclude merge commits
      *
-     * @example Custom plugins
-     * ```typescript
-     * const task = new ReleaseTask();
-     * const plugins = await task.usePlugins([
-     *   tuple(CustomPlugin, { option: 'value' })
-     * ]);
+     * When true, merge commits are filtered out from the changelog.
+     * @default true
+     *
+     * @example
+     * ```typescript
+     * noMerges: true  // Exclude merge commits
+     * noMerges: false // Include merge commits
      * ```
      */
-    usePlugins(externalTuples?: PluginTuple<PluginClass>[]): Promise<ScriptPlugin<ScriptContext<any>, ScriptPluginProps>[]>;
+    noMerges?: boolean;
     /**
-     * Executes the release task
+     * Commit type configurations
      *
-     * Internal method that runs the task through the executor.
-     * Preserves the context through the execution chain.
+     * Defines how different commit types should be handled and
+     * formatted in the changelog.
      *
-     * @returns Execution result
-     * @internal
+     * @example
+     * ```typescript
+     * types: [
+     *   { type: 'feat', section: '### Features' },
+     *   { type: 'fix', section: '### Bug Fixes' },
+     *   { type: 'chore', hidden: true }  // Skip chore commits
+     * ]
+     * ```
      */
-    run(): Promise<unknown>;
+    types?: {
+        type: string;
+        section?: string;
+        hidden?: boolean;
+    }[];
     /**
-     * Main entry point for executing the release task
-     *
-     * Checks environment conditions, loads plugins, and executes
-     * the release process. Supports additional plugin configuration
-     * at execution time.
+     * Template for formatting commit entries
      *
-     * Environment Control:
-     * - Checks FE_RELEASE environment variable
-     * - Skips release if FE_RELEASE=false
+     * Supports variables from CommitValue properties and adds:
+     * - ${scopeHeader}: Formatted scope
+     * - ${commitLink}: Commit hash link
+     * - ${prLink}: PR number link
      *
-     * @param externalTuples - Additional plugin configurations
-     * @returns Execution result
-     * @throws Error if release is skipped via environment variable
+     * @default '\n- ${scopeHeader} ${commitlint.message} ${commitLink} ${prLink}'
      *
-     * @example Basic execution
+     * @example
      * ```typescript
-     * const task = new ReleaseTask();
-     * await task.exec();
+     * formatTemplate: '* ${commitlint.message} (${commitLink})'
      * ```
+     */
+    formatTemplate?: string;
+    /**
+     * Whether to include commit message body
      *
-     * @example With additional plugins
-     * ```typescript
-     * const task = new ReleaseTask();
-     * await task.exec([
-     *   tuple(CustomPlugin, { option: 'value' })
-     * ]);
-     * ```
+     * When true, includes the full commit message body
+     * in the changelog entry.
      *
-     * @example Environment control
-     * ```typescript
-     * // Skip release
-     * process.env.FE_RELEASE = 'false';
+     * @since 2.3.0
+     * @default false
      *
-     * const task = new ReleaseTask();
-     * try {
-     *   await task.exec();
-     * } catch (e) {
-     *   if (e.message === 'Skip Release') {
-     *     console.log('Release skipped via environment variable');
-     *   }
-     * }
+     * @example
+     * ```typescript
+     * commitBody: true  // Include full commit message
      * ```
      */
-    exec(externalTuples?: PluginTuple<PluginClass>[]): Promise<unknown>;
-}
-
-type PackageJson$1 = Record<string, unknown>;
-interface WorkspacesProps extends ScriptPluginProps {
+    commitBody?: boolean;
     /**
-     * Whether to skip workspaces
+     * Template for dependency release entries
      *
-     * @default `false`
-     */
-    skip?: boolean;
-    /**
-     * Whether to skip checking the package.json file
+     * Used for formatting changelog entries related to dependency updates.
+     * Supports variables:
+     * - ${dep.name}: Dependency name
+     * - ${dep.oldVersion}: Previous version
+     * - ${dep.newVersion}: Updated version
      *
-     * @default `false`
-     */
-    skipCheckPackage?: boolean;
-    /**
-     * The workspace to publish
-     */
-    workspace?: WorkspaceValue;
-    /**
-     * The workspaces to publish
-     * @private
-     */
-    workspaces?: WorkspaceValue[];
-    /**
-     * The change labels
+     * @since 5.0.0
+     * @default '- Update dependency **${name}** from `${oldVersion}` to `${newVersion}`'
      *
-     * from `changePackagesLabel`
+     * @example
+     * ```typescript
+     * dependencyReleaseTemplate: '- Bump **${dep.name}** from `${dep.oldVersion}` to `${dep.newVersion}`'
+     * ```
      */
-    changeLabels?: string[];
+    dependencyReleaseTemplate?: string;
+}
+/**
+ * Raw commit message parsing result
+ *
+ * Represents a parsed conventional commit message with its
+ * component parts.
+ *
+ * @example
+ * ```typescript
+ * const tuple: CommitTuple = {
+ *   raw: 'feat(api): add new endpoint\n\nDetails here',
+ *   type: 'feat',
+ *   scope: 'api',
+ *   message: 'add new endpoint',
+ *   body: 'Details here'
+ * };
+ * ```
+ */
+interface CommitTuple {
+    /** Original commit message */
+    raw: string;
+    /** Commit type (e.g., 'feat', 'fix') */
+    type?: string;
+    /** Commit scope (e.g., 'api', 'core') */
+    scope?: string;
+    /** Main commit message */
+    message: string;
+    /** Optional commit body */
+    body?: string;
+}
+/**
+ * Parsed conventional commit data
+ *
+ * Represents a commit message parsed according to the
+ * conventional commit specification.
+ *
+ * Format: type(scope): message
+ *
+ * @example
+ * ```typescript
+ * const commit: Commitlint = {
+ *   type: 'feat',
+ *   scope: 'api',
+ *   message: 'add new endpoint',
+ *   body: 'Adds support for new API endpoint\n\nBREAKING CHANGE: API format changed'
+ * };
+ * ```
+ */
+interface Commitlint {
+    /** Commit type (e.g., 'feat', 'fix') */
+    type?: string;
+    /** Commit scope (e.g., 'api', 'core') */
+    scope?: string;
+    /** Main commit message */
+    message: string;
     /**
-     * The changed paths
-     * @private
+     * Commit message body with title removed
+     * @since 2.3.0
      */
-    changedPaths?: string[];
+    body?: string;
+}
+/**
+ * Complete commit information
+ *
+ * Combines Git commit data, parsed conventional commit info,
+ * and PR metadata into a single value object.
+ *
+ * @example
+ * ```typescript
+ * const commit: CommitValue = {
+ *   base: {
+ *     hash: 'abc123',
+ *     subject: 'feat(api): new endpoint (#123)'
+ *   },
+ *   commitlint: {
+ *     type: 'feat',
+ *     scope: 'api',
+ *     message: 'new endpoint'
+ *   },
+ *   commits: [],
+ *   prNumber: '123'
+ * };
+ * ```
+ */
+interface CommitValue {
+    /** Raw Git commit information */
+    base: BaseCommit;
+    /** Parsed conventional commit data */
+    commitlint: Commitlint;
+    /** Sub-commits (for merge commits) */
+    commits?: CommitValue[];
+    /** Associated pull request number */
+    prNumber?: string;
+}
+/**
+ * Interface for changelog formatting
+ *
+ * Defines the contract for classes that format commit data
+ * into changelog entries.
+ *
+ * @example
+ * ```typescript
+ * class MarkdownFormatter implements ChangelogFormatter {
+ *   format(commits: CommitValue[]): string[] {
+ *     return commits.map(commit =>
+ *       `- ${commit.commitlint.message} (#${commit.prNumber})`
+ *     );
+ *   }
+ * }
+ * ```
+ */
+interface ChangelogFormatter {
     /**
-     * The packages
-     * @private
+     * Formats commits into changelog entries
+     *
+     * @param commits - Array of commits to format
+     * @param options - Optional formatting options
+     * @returns Array of formatted changelog lines
      */
-    packages?: string[];
+    format<Opt extends GitChangelogOptions>(commits: unknown[], options?: Opt): string[];
+}
+/**
+ * Interface for changelog generation
+ *
+ * Defines the contract for classes that generate changelogs
+ * from Git history.
+ *
+ * @example
+ * ```typescript
+ * class GitChangelog implements ChangeLogInterface {
+ *   async getCommits(options?: GitChangelogOptions): Promise<CommitValue[]> {
+ *     // Get commits from Git and parse them
+ *     const commits = await gitlog(options);
+ *     return commits.map(commit => ({
+ *       base: commit,
+ *       commitlint: parseCommit(commit.subject),
+ *       commits: []
+ *     }));
+ *   }
+ * }
+ * ```
+ */
+interface ChangeLogInterface {
     /**
-     * All project packages mapping
-     * @private
+     * Retrieves and parses Git commits
+     *
+     * @param options - Optional Git log options
+     * @returns Promise resolving to array of parsed commits
      */
-    projectWorkspaces?: WorkspaceValue[];
+    getCommits(options?: GitChangelogOptions): Promise<CommitValue[]>;
 }
-interface WorkspaceValue {
-    name: string;
-    version: string;
+
+/**
+ * @module ChangesetVersion
+ * @description Changelog generation and changeset version/publish plugin
+ *
+ * Second plugin in the default release pipeline (after {@link Workspaces},
+ * before {@link Github}). Bridges git-based changelog formatting with the
+ * Changesets CLI for monorepo version bumps.
+ *
+ * Pipeline phases:
+ * - **onBefore**: validate `.changeset` directory; validate `NPM_TOKEN` when mode includes publish
+ * - **onExec**: generate per-workspace git changelogs (skips `dependencyRelease`
+ *   when `ignoreNonUpdatedPackages` is enabled)
+ * - **onSuccess**: run version and/or publish flow based on `mode`
+ *
+ * Version flow (`mode: 'version'` or first half of `'both'`):
+ * 1. Write `.changeset/*.md` files for directly changed packages only
+ * 2. Run `changeset version` (optionally with `changelog: false` when `onlyVersion`)
+ * 3. Optionally `git restore` dependency-release paths when `ignoreNonUpdatedPackages`
+ * 4. Sync workspace `newVersion` / `tagName` from disk via `mergeWorkspaces`
+ *
+ * @example Version-only release
+ * ```typescript
+ * // fe-config.json
+ * {
+ *   "release": {
+ *     "changesetVersion": {
+ *       "mode": "version",
+ *       "increment": "patch"
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @example Ignore internal dependent bumps
+ * ```bash
+ * fe-release --changesetVersion.ignore-non-updated-packages
+ * ```
+ *
+ * @see {@link ChangesetVersionProps.ignoreNonUpdatedPackages} for dependency-release behavior
+ */
+
+type ChangesetVersionMode = 'version' | 'publish' | 'both';
+interface ChangesetVersionProps extends GitChangelogOptions, ScriptPluginProps {
     /**
-     * The relative path of the workspace
+     * Work mode
+     *
+     * - `version`: generate git changelog, write changeset files, run `changeset version`
+     * - `publish`: run `changeset publish`
+     * - `both`: run `version` flow first, then `publish`
+     *
+     * @default 'version'
      */
-    path: string;
+    mode?: ChangesetVersionMode;
     /**
-     * The absolute path of the workspace
+     * Version increment type for generated changeset files
+     * @default 'patch'
      */
-    root: string;
+    increment?: string;
     /**
-     * The package.json of the workspace
+     * Whether to skip this plugin
+     * @default false
      */
-    packageJson: PackageJson$1;
+    skip?: boolean;
     /**
-     * The tag name of the workspace
-     * @private
+     * Whether to skip generating changeset files (version mode only)
+     * @default false
      */
-    tagName?: string;
+    skipChangeset?: boolean;
     /**
-     * The last tag name of the workspace
-     * @private
+     * Root directory of the changeset config
+     * @default '.changeset'
      */
-    lastTag?: string;
+    changesetRoot?: string;
     /**
-     * The changelog of the workspace
-     * @private
+     * When true, only bump package.json versions via changesets;
+     * do not write changelog content into CHANGELOG.md
+     * @default false
      */
-    changelog?: string;
-}
-
-type ReleaseParamsConfig = {
+    onlyVersion?: boolean;
     /**
-     * Max number of workspaces to include in the release name
+     * Control how internal dependency bump side-effects are handled during release.
      *
-     * @default 3
-     */
-    maxWorkspace?: number;
-    /**
-     * Multi-workspace separator
+     * ## Background
      *
-     * @default '_'
-     */
-    multiWorkspaceSeparator?: string;
-    /**
-     * Workspace version separator
+     * When a source package changes, `changeset version` may also bump its internal
+     * dependents (for example, `fe-scripts` depends on `scripts-context`).
+     * Dependents are tracked as `dependencyRelease` workspaces
+     * (see `workspaces.includeDependencyReleases`).
      *
-     * @default '@'
-     */
-    workspaceVersionSeparator?: string;
-    /**
-     * The branch name for batch release
+     * ## `false` (default) — keep dependent bumps
      *
-     * @default `batch-${releaseName}-${length}-packages-${timestamp}`
-     */
-    batchBranchName?: string;
-    /**
-     * The tag name for batch release
+     * 1. **Workspaces**: append dependents and set `dependencyRelease: true`
+     * 2. **Changelog**: generate git changelog for changed packages; dependents use
+     *    `dependencyReleaseTemplate` changelog
+     * 3. **Changeset files**: only created for directly changed packages
+     * 4. **`changeset version`**: bumps changed packages and dependents on disk
+     * 5. **Result**: `Updated workspaces` includes `(DEP)` entries; dependents may
+     *    be published together
      *
-     * @default `batch-${length}-packages-${timestamp}`
-     */
-    batchTagName?: string;
-    /**
-     * The PR title for batch release
+     * ## `true` — ignore dependent bumps (restore after version)
      *
-     * default from feConfig.release.PRTitle
+     * 1. **Workspaces**: append dependents for restore targeting (`lastTag` is still resolved)
+     * 2. **Changelog / changeset**: skip processing for `dependencyRelease` workspaces
+     * 3. **`changeset version`**: runs as usual (changesets may still touch dependents)
+     * 4. **Restore**: `git restore` all `dependencyRelease` workspace paths
+     * 5. **Result**: only directly changed packages remain bumped; they are the only
+     *    workspaces left for GitHub PR title/body/`release-tag-${count}-*` naming
      *
-     * @default `Release ${env} ${pkgName} ${tagName}`
-     */
-    PRTitle?: string;
-    /**
-     * The PR body for batch release
+     * @see {@link shouldProcessWorkspace} for the per-workspace processing gate
+     *
+     * CLI: `--changesetVersion.ignore-non-updated-packages`
+     * Alias: `--changelog.ignore-non-updated-packages`
      *
-     * default from feConfig.release.PRBody
+     * @default false
      */
-    PRBody?: string;
-};
+    ignoreNonUpdatedPackages?: boolean;
+}
+/**
+ * Manages changelog generation, changeset file creation, and Changesets CLI execution.
+ *
+ * Coordinates with {@link Workspaces} for workspace discovery and
+ * `dependencyRelease` tagging. Downstream {@link Github} consumes enriched
+ * changelogs and bumped versions produced here.
+ */
+declare class ChangesetVersion extends ScriptPlugin<ReleaseContext, ChangesetVersionProps> {
+    constructor(context: ReleaseContext, props?: ChangesetVersionProps);
+    get changesetRoot(): string;
+    get changesetConfigPath(): string;
+    protected get mode(): ChangesetVersionMode;
+    protected get ignoreNonUpdatedPackages(): boolean;
+    protected shouldProcessWorkspace(workspace: WorkspaceInterface): boolean;
+    protected getProcessableWorkspaces(workspaces: WorkspaceInterface[]): WorkspaceInterface[];
+    onBefore(): Promise<void>;
+    /**
+     * Ensure NPM_TOKEN is available and configured before changeset publish.
+     *
+     * Only required for `publish` / `both` modes. Version-only runs (release PR)
+     * do not need an npm auth token.
+     */
+    protected validateNpmToken(): Promise<void>;
+    onExec(_context: ReleaseContext): Promise<void>;
+    onSuccess(): Promise<void>;
+    protected logDryRun(message: string): void;
+    protected runVersionFlow(): Promise<void>;
+    protected runChangesetPublish(): Promise<void>;
+    protected syncWorkspaces(workspaces: WorkspaceInterface[]): void;
+    /**
+     * Rebuild `dependencyRelease` changelogs after source packages have `newVersion`.
+     *
+     * Workspaces appends dependents before `changeset version`, so the template can
+     * only use a provisional version. Once mergeWorkspaces reads bumped versions
+     * from disk, rewrite each dependent changelog with the real source bump.
+     */
+    protected refreshDependencyReleaseChangelogs(workspaces: WorkspaceInterface[]): WorkspaceInterface[];
+    mergeWorkspaces(workspaces: WorkspaceInterface[]): WorkspaceInterface[];
+    protected runChangesetVersion(onlyVersion?: boolean): Promise<void>;
+    restoreIgnorePackages(): Promise<void>;
+    generateChangelog(workspace: WorkspaceInterface): Promise<WorkspaceInterface>;
+    protected getChangelogWithGit(tagName: string, dir: string): Promise<string[]>;
+    protected generateTagName(workspace: WorkspaceInterface): string;
+    getIncrement(): string;
+    /**
+     * Labels that can override semver increment.
+     *
+     * Prefer explicit `workspaces.changeLabels`, then fall back to the PR labels
+     * from `GITHUB_EVENT_PATH` when running in GitHub Actions after a PR merge.
+     */
+    protected getIncrementLabels(): string[];
+    protected readGithubEventLabelNames(): string[];
+    generateChangesetFile(workspace: WorkspaceInterface): Promise<void>;
+}
 
 /**
- * Base configuration for Git-related plugins
+ * @module ReleaseLabel
+ * @description Release label management and file change detection
  *
- * Extends ScriptPluginProps with GitHub-specific configuration
- * options for API access and timeouts.
+ * This module provides utilities for managing release labels and detecting
+ * which packages have changed based on file paths. It supports custom
+ * comparison logic and label formatting.
  *
- * @example
+ * Core Features:
+ * - File change detection
+ * - Package path matching
+ * - Label generation
+ * - Custom comparison logic
+ *
+ * @example Basic usage
  * ```typescript
- * const config: GitBaseProps = {
- *   tokenRef: 'CUSTOM_TOKEN',
- *   timeout: 5000
- * };
+ * const label = new ReleaseLabel({
+ *   changePackagesLabel: 'changed:${name}',
+ *   packagesDirectories: ['packages/a', 'packages/b']
+ * });
+ *
+ * // Find changed packages
+ * const changed = label.pick(['packages/a/src/index.ts']);
+ * // ['packages/a']
+ *
+ * // Generate labels
+ * const labels = label.toChangeLabels(changed);
+ * // ['changed:packages/a']
+ * ```
+ *
+ * @example Custom comparison
+ * ```typescript
+ * const label = new ReleaseLabel({
+ *   changePackagesLabel: 'changed:${name}',
+ *   packagesDirectories: ['packages/a'],
+ *   compare: (file, pkg) => file.includes(pkg)
+ * });
+ *
+ * const changed = label.pick(['src/packages/a/index.ts']);
+ * // ['packages/a']
  * ```
  */
-interface GitBaseProps extends ScriptPluginProps {
+/**
+ * Function type for custom file path comparison
+ *
+ * Used to determine if a changed file belongs to a package.
+ * Default implementation checks if the file path starts with
+ * the package path.
+ *
+ * @param changedFilePath - Path of the changed file
+ * @param packagePath - Path of the package to check against
+ * @returns True if the file belongs to the package
+ */
+type ReleaseLabelCompare = (changedFilePath: string, packagePath: string) => boolean;
+interface ReleaseLabelOptions {
     /**
-     * Environment variable name for GitHub API token
-     *
-     * The value of this environment variable will be used
-     * for GitHub API authentication.
-     *
-     * @default 'GITHUB_TOKEN'
-     *
-     * @example
-     * ```typescript
-     * process.env.CUSTOM_TOKEN = 'ghp_123...';
-     * const config = { tokenRef: 'CUSTOM_TOKEN' };
-     * ```
+     * The change packages label
      */
-    tokenRef?: string;
+    changePackagesLabel: string;
     /**
-     * Timeout for GitHub API requests in milliseconds
-     *
-     * Controls how long to wait for GitHub API responses
-     * before timing out.
-     *
-     * @example
-     * ```typescript
-     * const config = { timeout: 5000 }; // 5 seconds
-     * ```
+     * The packages directories
      */
-    timeout?: number;
+    packagesDirectories: string[];
+    compare?: ReleaseLabelCompare;
 }
-
 /**
- * @module GithubPR
- * @description GitHub Pull Request and Release Management
+ * Core class for managing release labels and change detection
  *
- * This module provides functionality for managing GitHub pull requests
- * and releases as part of the release process. It handles PR creation,
- * release publishing, and changelog management.
+ * Provides utilities for detecting changed packages and generating
+ * appropriate labels. Supports custom comparison logic and label
+ * formatting.
  *
- * Core Features:
- * - Pull request creation and management
- * - Release publishing
- * - Changelog integration
- * - Tag management
- * - Label management
- * - Auto-merge support
+ * Features:
+ * - File change detection
+ * - Package path matching
+ * - Label generation
+ * - Custom comparison logic
  *
  * @example Basic usage
  * ```typescript
- * const plugin = new GithubPR(context, {
- *   releasePR: true,
- *   autoGenerate: true
+ * const label = new ReleaseLabel({
+ *   changePackagesLabel: 'changed:${name}',
+ *   packagesDirectories: ['packages/a', 'packages/b']
  * });
  *
- * await plugin.exec();
+ * // Find changed packages
+ * const changed = label.pick(['packages/a/src/index.ts']);
+ *
+ * // Generate labels
+ * const labels = label.toChangeLabels(changed);
  * ```
  *
- * @example Release publishing
+ * @example Custom comparison
  * ```typescript
- * const plugin = new GithubPR(context, {
- *   releasePR: false,
- *   makeLatest: true,
- *   preRelease: false
+ * const label = new ReleaseLabel({
+ *   changePackagesLabel: 'changed:${name}',
+ *   packagesDirectories: ['packages/a'],
+ *   compare: (file, pkg) => file.includes(pkg)
  * });
  *
- * await plugin.exec();
+ * const changed = label.pick(['src/packages/a/index.ts']);
  * ```
  */
-
-interface GithubPRProps extends ReleaseParamsConfig, GitBaseProps {
+declare class ReleaseLabel {
+    private readonly options;
+    /**
+     * Creates a new ReleaseLabel instance
+     *
+     * @param options - Configuration options for label management
+     *
+     * @example
+     * ```typescript
+     * const label = new ReleaseLabel({
+     *   // Label template with ${name} placeholder
+     *   changePackagesLabel: 'changed:${name}',
+     *
+     *   // Package directories to monitor
+     *   packagesDirectories: ['packages/a', 'packages/b'],
+     *
+     *   // Optional custom comparison logic
+     *   compare: (file, pkg) => file.includes(pkg)
+     * });
+     * ```
+     */
+    constructor(options: ReleaseLabelOptions);
+    /**
+     * Compares a changed file path against a package path
+     *
+     * Uses custom comparison function if provided, otherwise
+     * checks if the file path starts with the package path.
+     *
+     * @param changedFilePath - Path of the changed file
+     * @param packagePath - Path of the package to check against
+     * @returns True if the file belongs to the package
+     *
+     * @example
+     * ```typescript
+     * // Default comparison
+     * label.compare('packages/a/src/index.ts', 'packages/a');
+     * // true
+     *
+     * // Custom comparison
+     * const label = new ReleaseLabel({
+     *   ...options,
+     *   compare: (file, pkg) => file.includes(pkg)
+     * });
+     * label.compare('src/packages/a/index.ts', 'packages/a');
+     * // true
+     * ```
+     */
+    compare(changedFilePath: string, packagePath: string): boolean;
+    /**
+     * Generates a change label for a single package
+     *
+     * Replaces ${name} placeholder in the label template with
+     * the package path.
+     *
+     * @param packagePath - Path of the package
+     * @param label - Optional custom label template
+     * @returns Formatted change label
+     *
+     * @example
+     * ```typescript
+     * // Default label template
+     * label.toChangeLabel('packages/a');
+     * // 'changed:packages/a'
+     *
+     * // Custom label template
+     * label.toChangeLabel('packages/a', 'modified:${name}');
+     * // 'modified:packages/a'
+     * ```
+     */
+    toChangeLabel(packagePath: string, label?: string): string;
+    /**
+     * Generates change labels for multiple packages
+     *
+     * Maps each package path to a formatted change label.
+     *
+     * @param packages - Array of package paths
+     * @param label - Optional custom label template
+     * @returns Array of formatted change labels
+     *
+     * @example
+     * ```typescript
+     * // Default label template
+     * label.toChangeLabels(['packages/a', 'packages/b']);
+     * // ['changed:packages/a', 'changed:packages/b']
+     *
+     * // Custom label template
+     * label.toChangeLabels(
+     *   ['packages/a', 'packages/b'],
+     *   'modified:${name}'
+     * );
+     * // ['modified:packages/a', 'modified:packages/b']
+     * ```
+     */
+    toChangeLabels(packages: string[], label?: string): string[];
     /**
-     * Whether to dry run the creation of the pull request
+     * Identifies packages affected by changed files
+     *
+     * Checks each changed file against package paths to determine
+     * which packages have been modified.
+     *
+     * @param changedFiles - Array or Set of changed file paths
+     * @param packages - Optional array of package paths to check
+     * @returns Array of affected package paths
+     *
+     * @example
+     * ```typescript
+     * // Check against default packages
+     * label.pick(['packages/a/src/index.ts']);
+     * // ['packages/a']
      *
-     * - create pr
-     * - changeset publish
+     * // Check specific packages
+     * label.pick(
+     *   ['packages/a/index.ts', 'packages/b/test.ts'],
+     *   ['packages/a', 'packages/c']
+     * );
+     * // ['packages/a']
      *
-     * @default `false`
+     * // Using Set of files
+     * label.pick(new Set(['packages/a/index.ts']));
+     * // ['packages/a']
+     * ```
      */
-    dryRunCreatePR?: boolean;
+    pick(changedFiles: Array<string> | Set<string>, packages?: string[]): string[];
+}
+
+interface WorkspacesProps extends ScriptPluginProps {
     /**
-     * Whether to skip the release
+     * Whether to skip checking the package.json file
      *
      * @default `false`
      */
-    skip?: boolean;
+    skipCheckPackage?: boolean;
     /**
-     * Whether to publish a PR
-     *
-     * @default `false`
+     * The workspaces to publish
+     * @private
      */
-    releasePR?: boolean;
+    workspaces?: WorkspaceInterface[];
     /**
-     * The commit message of the release
-     *
-     * support WorkspaceValue
+     * The change labels
      *
-     * @default 'chore(tag): {{name}} v${version}'
+     * from `changePackagesLabel`
      */
-    commitMessage?: string;
+    changeLabels?: string[];
     /**
-     * The commit args of the release
-     *
-     * @default []
+     * The changed paths
+     * @private
      */
-    commitArgs?: string[];
+    changedPaths?: string[];
     /**
-     * The release name of the release
-     *
-     * @default 'Release ${name} v${version}'
+     * The packages
+     * @private
      */
-    releaseName?: string;
+    packages?: string[];
     /**
-     * Whether to create a draft release
-     *
-     * @default false
+     * All project packages mapping
+     * @private
      */
-    draft?: boolean;
+    projectWorkspaces?: WorkspaceInterface[];
     /**
-     * Whether to create a pre-release
+     * Template for generating release tag names after version bump
      *
-     * @default false
+     * Template variables support {@link WorkspaceInterface} properties.
+     *
+     * @default `'${name}@${version}'`
      */
-    preRelease?: boolean;
+    tagTemplate?: string;
     /**
-     * Whether to auto-generate the release notes
+     * Glob-style pattern for matching historical release tags
      *
-     * @default false
+     * @default `'${name}@*'`
      */
-    autoGenerate?: boolean;
+    tagMatch?: string;
     /**
-     * Whether to make the latest release
+     * Include internal dependents in the release workspace list.
+     *
+     * When enabled (default), packages that depend on a changed source are appended
+     * with `dependencyRelease: true`. This list is used for:
+     *
+     * - changelog / version logging when `changesetVersion.ignoreNonUpdatedPackages`
+     *   is `false`
+     * - `git restore` targeting when `changesetVersion.ignoreNonUpdatedPackages`
+     *   is `true`
      *
      * @default true
      */
-    makeLatest?: boolean | 'true' | 'false' | 'legacy';
+    includeDependencyReleases?: boolean;
     /**
-     * The release notes of the release
+     * Directories containing packages for monorepo releases
+     *
+     * Core concept:
+     * Specifies the directories that contain packages for
+     * monorepo release management, enabling selective
+     * package discovery and release coordination.
+     *
+     * Directory patterns:
+     * - Supports glob patterns for flexible matching
+     * - Enables selective package inclusion
+     * - Supports nested directory structures
+     * - Facilitates monorepo organization
+     * - Enables workspace-specific configurations
+     *
+     * Use cases:
+     * - Monorepo package discovery
+     * - Selective package releases
+     * - Workspace-specific configurations
+     * - Multi-package coordination
+     * - Dependency-aware releases
+     *
+     * @optional
+     * @default `[]`
+     * @example Basic package directories
+     * ```typescript
+     * const config: FeReleaseConfig = {
+     *   packagesDirectories: ['packages/*']
+     * };
+     * ```
      *
-     * @default undefined
+     * @example Multiple package directories
+     * ```typescript
+     * const config: FeReleaseConfig = {
+     *   packagesDirectories: ['packages/*', 'apps/*', 'libs/*']
+     * };
+     * ```
      */
-    releaseNotes?: string;
+    packagesDirectories?: string[];
     /**
-     * The discussion category name of the release
+     * Git ref used as the left side of `git diff <compareRef>...HEAD`
+     * when detecting changed packages.
+     *
+     * Defaults to `origin/<sourceBranch>`, then falls back to the merged PR base
+     * SHA from `GITHUB_EVENT_PATH` when running after a GitHub Actions PR merge
+     * into the same branch (where `origin/<sourceBranch>...HEAD` is empty).
      *
-     * @default undefined
+     * @optional
+     * @example `'abc1234'` or `'origin/master'`
      */
-    discussionCategoryName?: string;
+    compareRef?: string;
     /**
-     * Whether to push the changed labels to the release PR
+     * Template for package change labels in monorepos
      *
-     * @default false
+     * Core concept:
+     * Defines the naming pattern for labels that identify
+     * which packages have changed in monorepo releases,
+     * enabling targeted review and deployment.
+     *
+     * Label usage:
+     * - Applied to PRs when specific packages change
+     * - Enables package-specific review processes
+     * - Supports selective deployment strategies
+     * - Improves monorepo change tracking
+     * - Facilitates team collaboration and review
+     *
+     * Template variables:
+     * - `${name}`: Package name for label identification
+     *
+     * @optional
+     * @default `'changes:${name}'`
+     * @example Basic change label
+     * ```typescript
+     * const config: FeReleaseConfig = {
+     *   changePackagesLabel: 'changes:${name}'
+     * };
+     * ```
+     *
+     * @example Custom change label
+     * ```typescript
+     * const config: FeReleaseConfig = {
+     *   changePackagesLabel: 'package:${name}'
+     * };
+     * ```
      */
-    pushChangeLabels?: boolean;
+    changePackagesLabel?: string;
 }
 
+/**
+ * @module FeReleaseDefaults
+ * @description Internal constants for fe-release
+ *
+ * User-facing default configuration lives in `release.json` and is
+ * injected into {@link ReleaseContext} at construction time.
+ */
+/**
+ * Default name for the release task context (fe-config.json key)
+ */
+declare const defaultReleaaseName = "release";
+/**
+ * Path to package manifest file
+ */
+declare const MANIFEST_PATH = "package.json";
+/**
+ * Template opening delimiter
+ */
+declare const TEMPLATE_OPEN = "{{";
+declare const releaseJson: {
+    readonly sourceBranch: "master";
+    readonly releaseEnv: "development";
+    readonly github: {
+        readonly mode: "createPR";
+        readonly mergeType: "squash";
+        readonly autoMergeReleasePR: false;
+        readonly pushChangeLabels: false;
+        readonly skipCreateReleasePR: false;
+        readonly PRTitle: "Release ${env} ${pkgName} ${tagName}";
+        readonly PRBody: "## Changelog\n\n${changelog}";
+        readonly batchPRBody: "\n## ${name} ${newVersion}\n${changelog}\n";
+        readonly branchName: "release/${repoName}-${releaseId}";
+        readonly releaseTagName: "release-tag-${count}-patch-${releaseId}";
+        readonly commitMessage: "chore(release): ${spaces}";
+        readonly label: {
+            readonly name: "CI-Release";
+            readonly color: "1A7F37";
+            readonly description: "Release PR";
+        };
+    };
+    readonly changesetVersion: {
+        readonly mode: "version";
+        readonly increment: "patch";
+        readonly changesetRoot: ".changeset";
+        readonly ignoreNonUpdatedPackages: false;
+        readonly dependencyReleaseTemplate: "- Update dependency **${name}** from `${oldVersion}` to `${newVersion}`";
+        readonly formatTemplate: "\n- ${scopeHeader} ${commitlint.message} ${commitLink} ${prLink}";
+        readonly types: readonly [{
+            readonly type: "feat";
+            readonly section: "#### ✨ Features";
+            readonly hidden: false;
+        }, {
+            readonly type: "fix";
+            readonly section: "#### 🐞 Bug Fixes";
+            readonly hidden: false;
+        }, {
+            readonly type: "chore";
+            readonly section: "#### 🔧 Chores";
+            readonly hidden: true;
+        }, {
+            readonly type: "docs";
+            readonly section: "#### 📝 Documentation";
+            readonly hidden: false;
+        }, {
+            readonly type: "refactor";
+            readonly section: "#### ♻️ Refactors";
+            readonly hidden: false;
+        }, {
+            readonly type: "perf";
+            readonly section: "#### 🚀 Performance";
+            readonly hidden: false;
+        }, {
+            readonly type: "test";
+            readonly section: "#### 🚨 Tests";
+            readonly hidden: true;
+        }, {
+            readonly type: "style";
+            readonly section: "#### 🎨 Styles";
+            readonly hidden: true;
+        }, {
+            readonly type: "ci";
+            readonly section: "#### 🔄 CI";
+            readonly hidden: true;
+        }, {
+            readonly type: "build";
+            readonly section: "#### 🚧 Build";
+            readonly hidden: false;
+        }, {
+            readonly type: "revert";
+            readonly section: "#### ⏪ Reverts";
+            readonly hidden: true;
+        }, {
+            readonly type: "release";
+            readonly section: "#### 🔖 Releases";
+            readonly hidden: true;
+        }];
+    };
+    readonly workspaces: {
+        readonly tagTemplate: "${name}@${version}";
+        readonly tagMatch: "${name}@*";
+        readonly includeDependencyReleases: true;
+    };
+};
+
 /**
  * @module FeReleaseTypes
  * @description Type definitions for the fe-release framework
@@ -761,7 +1561,7 @@ type ReleaseReturnValue = {
  * ```
  */
 type DeepPartial<T> = {
-    [P in keyof T]?: DeepPartial<T[P]>;
+    [P in keyof T]?: string extends keyof T[P] ? T[P] : T[P] extends object ? DeepPartial<T[P]> : T[P];
 };
 /**
  * Configuration interface for release process
@@ -784,8 +1584,16 @@ type DeepPartial<T> = {
  * ```
  */
 interface ReleaseConfig extends ScriptSharedInterface {
-    githubPR?: GithubPRProps;
+    changesetVersion?: ChangesetVersionProps;
+    github?: GithubProps;
     workspaces?: WorkspacesProps;
+    /** Repository name without owner */
+    repoName?: string;
+    /** Repository owner / org / namespace */
+    authorName?: string;
+    releaseEnv?: string;
+    currentBranch?: string;
+    releaseId?: string;
 }
 /**
  * Options interface for release context
@@ -858,27 +1666,190 @@ type PackageJson = Record<string, unknown>;
  * adds template-specific properties. Includes deprecated fields
  * with migration guidance.
  *
- * @example
+ * @example
+ * ```typescript
+ * const context: TemplateContext = {
+ *   publishPath: './dist',
+ *   env: 'production',      // Deprecated
+ *   branch: 'main',         // Deprecated
+ *   // ... other properties from ReleaseContextOptions
+ * };
+ * ```
+ */
+interface TemplateContext extends ReleaseContextOptions$1, WorkspaceInterface {
+    publishPath: string;
+    /**
+     * @deprecated  use `releaseEnv` from `shared`
+     */
+    env: string;
+    /**
+     * @deprecated  use `sourceBranch` from `shared`
+     */
+    branch: string;
+}
+interface ReleaseGlobalConfig {
+    /**
+     * The github PR of the project
+     * @private
+     */
+    github?: GithubProps;
+    /**
+     * Changeset version/publish plugin options
+     * @private
+     */
+    changesetVersion?: ChangesetVersionProps;
+    /**
+     * The workspaces of the project
+     * @private
+     */
+    workspaces?: WorkspacesProps;
+}
+declare module '@qlover/scripts-context' {
+    interface FeConfig {
+        [defaultReleaaseName]?: ReleaseGlobalConfig;
+    }
+}
+
+/**
+ * @module PluginTuple
+ * @description Type-safe plugin tuple creation and handling
+ *
+ * This module provides utilities for creating and handling tuples that
+ * represent plugin configurations. It ensures type safety when working
+ * with plugin constructors and their parameters.
+ *
+ * Core Features:
+ * - Type-safe plugin class handling
+ * - Constructor parameter inference
+ * - Plugin tuple creation
+ *
+ * @example Basic usage
+ * ```typescript
+ * class MyPlugin extends ScriptPlugin {
+ *   constructor(context: ScriptContext, config: { option: string }) {
+ *     super(context);
+ *   }
+ * }
+ *
+ * const pluginTuple = tuple(MyPlugin, { option: 'value' });
+ * // [MyPlugin, { option: 'value' }]
+ * ```
+ *
+ * @example Plugin name string
+ * ```typescript
+ * const pluginTuple = tuple('MyPlugin', { option: 'value' });
+ * // ['MyPlugin', { option: 'value' }]
+ * ```
+ */
+
+/**
+ * Plugin class constructor type
+ *
+ * Represents a constructor for a class that extends ScriptPlugin.
+ * Supports generic constructor arguments.
+ *
+ * @template T - Array type for constructor arguments
+ *
+ * @example
+ * ```typescript
+ * class MyPlugin extends ScriptPlugin {
+ *   constructor(context: ScriptContext, config: { option: string }) {
+ *     super(context);
+ *   }
+ * }
+ *
+ * const PluginCtor: PluginClass = MyPlugin;
+ * ```
+ */
+type PluginClass<T extends unknown[] = any[]> = new (...args: T) => ScriptPlugin<ScriptContext<any>, ScriptPluginProps>;
+/**
+ * Plugin constructor parameters type
+ *
+ * Extracts the constructor parameter types for a plugin class,
+ * excluding the first parameter (context). Uses TypeScript's
+ * conditional types and inference to extract parameter types.
+ *
+ * @template T - Plugin class type
+ *
+ * @example
+ * ```typescript
+ * class MyPlugin extends ScriptPlugin {
+ *   constructor(
+ *     context: ScriptContext,
+ *     config: { option: string },
+ *     extra: number
+ *   ) {
+ *     super(context);
+ *   }
+ * }
+ *
+ * // Type: [{ option: string }, number]
+ * type Params = PluginConstructorParams<typeof MyPlugin>;
+ * ```
+ */
+type PluginConstructorParams<T extends PluginClass> = T extends new (first: any, ...args: infer P) => unknown ? P : never;
+/**
+ * Plugin configuration tuple type
+ *
+ * Represents a tuple containing a plugin class (or name) and its
+ * constructor arguments. Used for plugin registration and loading.
+ *
+ * @template T - Plugin class type
+ *
+ * @example
+ * ```typescript
+ * class MyPlugin extends ScriptPlugin {
+ *   constructor(context: ScriptContext, config: { option: string }) {
+ *     super(context);
+ *   }
+ * }
+ *
+ * // Type: [typeof MyPlugin, { option: string }]
+ * type Tuple = PluginTuple<typeof MyPlugin>;
+ *
+ * // Type: [string, { option: string }]
+ * type StringTuple = PluginTuple<'MyPlugin'>;
+ * ```
+ */
+type PluginTuple<T extends PluginClass> = [
+    T | string,
+    ...PluginConstructorParams<T>
+];
+/**
+ * Creates a type-safe plugin configuration tuple
+ *
+ * Helper function for creating tuples that represent plugin
+ * configurations with proper type inference for constructor
+ * arguments.
+ *
+ * @template T - Plugin class type
+ * @param plugin - Plugin class or name
+ * @param args - Plugin constructor arguments
+ * @returns Plugin configuration tuple
+ *
+ * @example Class-based plugin
+ * ```typescript
+ * class MyPlugin extends ScriptPlugin {
+ *   constructor(
+ *     context: ScriptContext,
+ *     config: { option: string },
+ *     extra: number
+ *   ) {
+ *     super(context);
+ *   }
+ * }
+ *
+ * const config = tuple(MyPlugin, { option: 'value' }, 42);
+ * // [MyPlugin, { option: 'value' }, 42]
+ * ```
+ *
+ * @example String-based plugin
  * ```typescript
- * const context: TemplateContext = {
- *   publishPath: './dist',
- *   env: 'production',      // Deprecated
- *   branch: 'main',         // Deprecated
- *   // ... other properties from ReleaseContextOptions
- * };
+ * const config = tuple('MyPlugin', { option: 'value' });
+ * // ['MyPlugin', { option: 'value' }]
  * ```
  */
-interface TemplateContext extends ReleaseContextOptions$1, WorkspaceValue {
-    publishPath: string;
-    /**
-     * @deprecated  use `releaseEnv` from `shared`
-     */
-    env: string;
-    /**
-     * @deprecated  use `sourceBranch` from `shared`
-     */
-    branch: string;
-}
+declare function tuple<T extends PluginClass>(plugin: T | string, ...args: PluginConstructorParams<T>): PluginTuple<T>;
 
 /**
  * @module ReleaseContext
@@ -933,17 +1904,7 @@ interface TemplateContext extends ReleaseContextOptions$1, WorkspaceValue {
 
 interface ReleaseContextOptions extends ScriptContextInterface<ReleaseContextConfig> {
 }
-interface ReleaseContextConfig extends FeReleaseConfig, ScriptSharedInterface {
-    /**
-     * The github PR of the project
-     * @private
-     */
-    githubPR?: GithubPRProps;
-    /**
-     * The workspaces of the project
-     * @private
-     */
-    workspaces?: WorkspacesProps;
+interface ReleaseContextConfig extends ReleaseGlobalConfig, ScriptSharedInterface {
     /**
      * The environment of the project
      *
@@ -969,6 +1930,12 @@ interface ReleaseContextConfig extends FeReleaseConfig, ScriptSharedInterface {
      * The current branch of the project
      */
     currentBranch?: string;
+    /**
+     * Unique identifier for the current release run
+     *
+     * @private
+     */
+    releaseId?: string;
 }
 /**
  * Core context class for release operations
@@ -1004,6 +1971,8 @@ interface ReleaseContextConfig extends FeReleaseConfig, ScriptSharedInterface {
  * ```
  */
 declare class ReleaseContext extends ScriptContext<ReleaseContextConfig> {
+    protected templateEngine: TemplateEngine;
+    protected compileMap: Map<string, RenderFn>;
     /**
      * Creates a new ReleaseContext instance
      *
@@ -1014,7 +1983,7 @@ declare class ReleaseContext extends ScriptContext<ReleaseContextConfig> {
      * - releaseEnv: Uses environment variables or 'development'
      *
      * Environment Variable Priority:
-     * - sourceBranch: FE_RELEASE_BRANCH > FE_RELEASE_SOURCE_BRANCH > DEFAULT_SOURCE_BRANCH
+     * - sourceBranch: FE_RELEASE_BRANCH > FE_RELEASE_SOURCE_BRANCH > release.json
      * - releaseEnv: FE_RELEASE_ENV > NODE_ENV > 'development'
      *
      * @param name - Unique identifier for this release context
@@ -1066,6 +2035,10 @@ declare class ReleaseContext extends ScriptContext<ReleaseContextConfig> {
      * ```
      */
     get releaseEnv(): string;
+    /**
+     * Gets the unique identifier for the current release run
+     */
+    get releaseId(): string;
     /**
      * Gets all configured workspaces
      *
@@ -1077,19 +2050,7 @@ declare class ReleaseContext extends ScriptContext<ReleaseContextConfig> {
      * // [{ name: 'pkg-a', version: '1.0.0', ... }]
      * ```
      */
-    get workspaces(): WorkspaceValue[] | undefined;
-    /**
-     * Gets the current active workspace
-     *
-     * @returns Current workspace configuration or undefined
-     *
-     * @example
-     * ```typescript
-     * const current = context.workspace;
-     * // { name: 'pkg-a', version: '1.0.0', ... }
-     * ```
-     */
-    get workspace(): WorkspaceValue | undefined;
+    get workspaces(): WorkspaceInterface[] | undefined;
     /**
      * Sets the workspace configurations
      *
@@ -1102,38 +2063,18 @@ declare class ReleaseContext extends ScriptContext<ReleaseContextConfig> {
      * context.setWorkspaces([{
      *   name: 'pkg-a',
      *   version: '1.0.0',
-     *   path: 'packages/a'
+     *   path: 'packages/a',
+     *   lastTag: 'pkg-aV1.0.0'
      * }]);
      * ```
      */
-    setWorkspaces(workspaces: WorkspaceValue[]): void;
+    setWorkspaces(workspaces: WorkspaceInterface[]): void;
     /**
-     * Gets package.json data for the current workspace
-     *
-     * Provides type-safe access to package.json fields with optional
-     * path and default value support.
-     *
-     * @param key - Optional dot-notation path to specific field
-     * @param defaultValue - Default value if field not found
-     * @returns Package data of type T
-     * @throws Error if package.json not found
-     *
-     * @example Basic usage
-     * ```typescript
-     * // Get entire package.json
-     * const pkg = context.getPkg();
-     *
-     * // Get specific field
-     * const version = context.getPkg<string>('version');
-     *
-     * // Get nested field with default
-     * const script = context.getPkg<string>(
-     *   'scripts.build',
-     *   'echo "No build script"'
-     * );
-     * ```
+     * @deprecated use `getParameters` or use `context.parameters`(type safe)
+     * @param key
+     * @param defaultValue
      */
-    getPkg<T>(key?: string, defaultValue?: T): T;
+    getOptions<T = unknown>(key?: keyof ReleaseContextConfig | (keyof ReleaseContextConfig)[], defaultValue?: T): T;
     /**
      * Generates template context for string interpolation
      *
@@ -1149,590 +2090,303 @@ declare class ReleaseContext extends ScriptContext<ReleaseContextConfig> {
      * // {
      * //   publishPath: 'packages/my-pkg',
      * //   env: 'production',        // deprecated
-     * //   branch: 'main',          // deprecated
-     * //   releaseEnv: 'production', // use this instead
-     * //   sourceBranch: 'main',    // use this instead
-     * //   ...other options
-     * // }
-     * ```
-     */
-    getTemplateContext(): TemplateContext;
-    /**
-     * Executes changeset CLI commands
-     *
-     * Automatically detects and uses appropriate package manager
-     * (pnpm or npx) to run changeset commands.
-     *
-     * @param name - Changeset command name
-     * @param args - Optional command arguments
-     * @returns Command output
-     *
-     * @example Version bump
-     * ```typescript
-     * // Bump version with snapshot
-     * await context.runChangesetsCli('version', ['--snapshot', 'alpha']);
-     *
-     * // Create new changeset
-     * await context.runChangesetsCli('add');
-     *
-     * // Status check
-     * await context.runChangesetsCli('status');
-     * ```
-     */
-    runChangesetsCli(name: string, args?: string[]): Promise<string>;
-}
-
-/**
- * @module ReleaseLabel
- * @description Release label management and file change detection
- *
- * This module provides utilities for managing release labels and detecting
- * which packages have changed based on file paths. It supports custom
- * comparison logic and label formatting.
- *
- * Core Features:
- * - File change detection
- * - Package path matching
- * - Label generation
- * - Custom comparison logic
- *
- * @example Basic usage
- * ```typescript
- * const label = new ReleaseLabel({
- *   changePackagesLabel: 'changed:${name}',
- *   packagesDirectories: ['packages/a', 'packages/b']
- * });
- *
- * // Find changed packages
- * const changed = label.pick(['packages/a/src/index.ts']);
- * // ['packages/a']
- *
- * // Generate labels
- * const labels = label.toChangeLabels(changed);
- * // ['changed:packages/a']
- * ```
- *
- * @example Custom comparison
- * ```typescript
- * const label = new ReleaseLabel({
- *   changePackagesLabel: 'changed:${name}',
- *   packagesDirectories: ['packages/a'],
- *   compare: (file, pkg) => file.includes(pkg)
- * });
- *
- * const changed = label.pick(['src/packages/a/index.ts']);
- * // ['packages/a']
- * ```
- */
-/**
- * Function type for custom file path comparison
- *
- * Used to determine if a changed file belongs to a package.
- * Default implementation checks if the file path starts with
- * the package path.
- *
- * @param changedFilePath - Path of the changed file
- * @param packagePath - Path of the package to check against
- * @returns True if the file belongs to the package
- */
-type ReleaseLabelCompare = (changedFilePath: string, packagePath: string) => boolean;
-interface ReleaseLabelOptions {
-    /**
-     * The change packages label
-     */
-    changePackagesLabel: string;
-    /**
-     * The packages directories
-     */
-    packagesDirectories: string[];
-    compare?: ReleaseLabelCompare;
-}
-/**
- * Core class for managing release labels and change detection
- *
- * Provides utilities for detecting changed packages and generating
- * appropriate labels. Supports custom comparison logic and label
- * formatting.
- *
- * Features:
- * - File change detection
- * - Package path matching
- * - Label generation
- * - Custom comparison logic
- *
- * @example Basic usage
- * ```typescript
- * const label = new ReleaseLabel({
- *   changePackagesLabel: 'changed:${name}',
- *   packagesDirectories: ['packages/a', 'packages/b']
- * });
- *
- * // Find changed packages
- * const changed = label.pick(['packages/a/src/index.ts']);
- *
- * // Generate labels
- * const labels = label.toChangeLabels(changed);
- * ```
- *
- * @example Custom comparison
- * ```typescript
- * const label = new ReleaseLabel({
- *   changePackagesLabel: 'changed:${name}',
- *   packagesDirectories: ['packages/a'],
- *   compare: (file, pkg) => file.includes(pkg)
- * });
- *
- * const changed = label.pick(['src/packages/a/index.ts']);
- * ```
- */
-declare class ReleaseLabel {
-    private readonly options;
-    /**
-     * Creates a new ReleaseLabel instance
-     *
-     * @param options - Configuration options for label management
-     *
-     * @example
-     * ```typescript
-     * const label = new ReleaseLabel({
-     *   // Label template with ${name} placeholder
-     *   changePackagesLabel: 'changed:${name}',
-     *
-     *   // Package directories to monitor
-     *   packagesDirectories: ['packages/a', 'packages/b'],
-     *
-     *   // Optional custom comparison logic
-     *   compare: (file, pkg) => file.includes(pkg)
-     * });
-     * ```
-     */
-    constructor(options: ReleaseLabelOptions);
-    /**
-     * Compares a changed file path against a package path
-     *
-     * Uses custom comparison function if provided, otherwise
-     * checks if the file path starts with the package path.
-     *
-     * @param changedFilePath - Path of the changed file
-     * @param packagePath - Path of the package to check against
-     * @returns True if the file belongs to the package
-     *
-     * @example
-     * ```typescript
-     * // Default comparison
-     * label.compare('packages/a/src/index.ts', 'packages/a');
-     * // true
-     *
-     * // Custom comparison
-     * const label = new ReleaseLabel({
-     *   ...options,
-     *   compare: (file, pkg) => file.includes(pkg)
-     * });
-     * label.compare('src/packages/a/index.ts', 'packages/a');
-     * // true
-     * ```
-     */
-    compare(changedFilePath: string, packagePath: string): boolean;
-    /**
-     * Generates a change label for a single package
-     *
-     * Replaces ${name} placeholder in the label template with
-     * the package path.
-     *
-     * @param packagePath - Path of the package
-     * @param label - Optional custom label template
-     * @returns Formatted change label
-     *
-     * @example
-     * ```typescript
-     * // Default label template
-     * label.toChangeLabel('packages/a');
-     * // 'changed:packages/a'
-     *
-     * // Custom label template
-     * label.toChangeLabel('packages/a', 'modified:${name}');
-     * // 'modified:packages/a'
+     * //   branch: 'main',          // deprecated
+     * //   releaseEnv: 'production', // use this instead
+     * //   sourceBranch: 'main',    // use this instead
+     * //   ...other options
+     * // }
      * ```
      */
-    toChangeLabel(packagePath: string, label?: string): string;
+    getTemplateContext(): TemplateContext;
     /**
-     * Generates change labels for multiple packages
+     * Executes changeset CLI commands
      *
-     * Maps each package path to a formatted change label.
+     * Automatically detects and uses appropriate package manager
+     * (pnpm or npx) to run changeset commands.
      *
-     * @param packages - Array of package paths
-     * @param label - Optional custom label template
-     * @returns Array of formatted change labels
+     * @param name - Changeset command name
+     * @param args - Optional command arguments
+     * @returns Command output
      *
-     * @example
+     * @example Version bump
      * ```typescript
-     * // Default label template
-     * label.toChangeLabels(['packages/a', 'packages/b']);
-     * // ['changed:packages/a', 'changed:packages/b']
+     * // Bump version with snapshot
+     * await context.runChangesetsCli('version', ['--snapshot', 'alpha']);
      *
-     * // Custom label template
-     * label.toChangeLabels(
-     *   ['packages/a', 'packages/b'],
-     *   'modified:${name}'
-     * );
-     * // ['modified:packages/a', 'modified:packages/b']
+     * // Create new changeset
+     * await context.runChangesetsCli('add');
+     *
+     * // Status check
+     * await context.runChangesetsCli('status');
      * ```
      */
-    toChangeLabels(packages: string[], label?: string): string[];
+    runChangesetsCli(name: string, args?: string[]): Promise<string>;
     /**
-     * Identifies packages affected by changed files
+     * Gets the workspaces of the project
      *
-     * Checks each changed file against package paths to determine
-     * which packages have been modified.
+     * If no workspaces are found, throws an error.
      *
-     * @param changedFiles - Array or Set of changed file paths
-     * @param packages - Optional array of package paths to check
-     * @returns Array of affected package paths
+     * @throws Error if no workspaces are found
+     * @returns The workspaces of the project
      *
      * @example
      * ```typescript
-     * // Check against default packages
-     * label.pick(['packages/a/src/index.ts']);
-     * // ['packages/a']
+     * const workspaces = context.requireWorkspaces();
+     * // [{ name: 'pkg-a', version: '1.0.0', ... }]
+     * ```
+     */
+    requireWorkspaces(): WorkspaceInterface[];
+    /**
+     * Format a template with the given data
      *
-     * // Check specific packages
-     * label.pick(
-     *   ['packages/a/index.ts', 'packages/b/test.ts'],
-     *   ['packages/a', 'packages/c']
-     * );
-     * // ['packages/a']
+     * The template will be compiled only once and cached for future use.
      *
-     * // Using Set of files
-     * label.pick(new Set(['packages/a/index.ts']));
-     * // ['packages/a']
-     * ```
+     * @param template - The template to format
+     * @param data - The data to format the template with
+     * @returns The formatted template
      */
-    pick(changedFiles: Array<string> | Set<string>, packages?: string[]): string[];
+    format(template: string, data: Record<string, any>): string;
+    getTemplateEngine(): TemplateEngine;
 }
 
 /**
- * @module ChangeLog
- * @description Core interfaces for changelog generation
+ * @module ReleaseTask
+ * @description Task orchestration for release process
  *
- * This module provides the core interfaces and types for generating
- * changelogs from Git commit history. It includes types for commit
- * parsing, formatting, and changelog generation.
+ * This module provides the core task orchestration for the release process,
+ * managing plugin loading, execution order, and context handling. It serves
+ * as the main entry point for executing release operations.
  *
- * Core Components:
- * - Commit data structures
- * - Changelog formatting
- * - Git log options
- * - Changelog generation
+ * Core Features:
+ * - Plugin management and execution
+ * - Release context initialization
+ * - Task execution control
+ * - Environment-based control
+ *
+ * Default Plugins:
+ * - Workspaces: Monorepo workspace management
+ * - Changelog: Version and changelog management
+ * - GithubPR: Pull request creation and management
  *
  * @example Basic usage
  * ```typescript
- * class MyChangeLog implements ChangeLogInterface {
- *   async getCommits(options?: GitChangelogOptions): Promise<CommitValue[]> {
- *     // Implementation
+ * // Initialize and execute
+ * const task = new ReleaseTask({
+ *   rootPath: '/path/to/project',
+ *   sourceBranch: 'main'
+ * });
+ *
+ * await task.exec();
+ * ```
+ *
+ * @example Custom plugins
+ * ```typescript
+ * import { tuple } from '@qlover/fe-release';
+ *
+ * // Add custom plugin
+ * class CustomPlugin extends ScriptPlugin {
+ *   async onExec() {
+ *     // Custom release logic
  *   }
  * }
  *
- * class MyFormatter implements ChangelogFormatter {
- *   format(commits: CommitValue[]): string[] {
- *     // Implementation
- *   }
+ * const task = new ReleaseTask({}, new LifecycleExecutor<ReleaseContext>(), [
+ *   tuple(CustomPlugin, { option: 'value' })
+ * ]);
+ *
+ * await task.exec();
+ * ```
+ *
+ * @example Environment control
+ * ```typescript
+ * // Skip release
+ * process.env.FE_RELEASE = 'false';
+ *
+ * const task = new ReleaseTask();
+ * try {
+ *   await task.exec();
+ * } catch (e) {
+ *   // Handle "Skip Release" error
  * }
  * ```
  */
 
 /**
- * Base commit type mapping Git commit fields
+ * Core task class for managing release operations
  *
- * Maps all available Git commit fields to optional string values.
- * Uses the CommitField type from gitlog package to ensure type safety.
+ * Handles plugin orchestration, task execution, and context management
+ * for the release process. Supports both built-in and custom plugins.
  *
- * Available fields include:
- * - hash: Full commit hash
- * - abbrevHash: Abbreviated commit hash
- * - subject: Commit message subject
- * - authorName: Author's name
- * - authorDate: Author date
- * - And many more from gitlog.CommitField
+ * Features:
+ * - Plugin lifecycle management
+ * - Task execution control
+ * - Context initialization and access
+ * - Environment-based control
  *
- * @example
+ * @example Basic initialization
  * ```typescript
- * const commit: BaseCommit = {
- *   hash: 'abc123def456',
- *   abbrevHash: 'abc123',
- *   subject: 'feat: new feature',
- *   authorName: 'John Doe',
- *   authorDate: '2023-01-01'
- * };
+ * const task = new ReleaseTask({
+ *   rootPath: '/path/to/project'
+ * });
  * ```
- */
-type BaseCommit = {
-    [key in CommitField]: string | undefined;
-};
-/**
- * Configuration options for changelog generation
- *
- * Provides comprehensive options for controlling how changelogs
- * are generated from Git history, including commit range selection,
- * formatting, and filtering.
  *
- * @example Basic usage
+ * @example Custom executor
  * ```typescript
- * const options: GitChangelogOptions = {
- *   from: 'v1.0.0',
- *   to: 'v2.0.0',
- *   directory: 'packages/my-pkg',
- *   noMerges: true
- * };
+ * const executor = new LifecycleExecutor<ReleaseContext>({
+ *   onError: (err) => console.error('Release failed:', err)
+ * });
+ *
+ * const task = new ReleaseTask({}, executor);
  * ```
  *
- * @example Custom formatting
+ * @example Custom plugins
  * ```typescript
- * const options: GitChangelogOptions = {
- *   types: [
- *     { type: 'feat', section: '### Features' },
- *     { type: 'fix', section: '### Bug Fixes' }
- *   ],
- *   formatTemplate: '* ${commitlint.message} ${prLink}',
- *   commitBody: true
- * };
+ * const task = new ReleaseTask(
+ *   {}, // options
+ *   new LifecycleExecutor<ReleaseContext>(),
+ *   [
+ *     tuple(CustomPlugin, { config: 'value' }),
+ *     ...innerTuples // include default plugins
+ *   ]
+ * );
  * ```
  */
-interface GitChangelogOptions {
+declare class ReleaseTask {
+    protected executor: LifecycleExecutor<ReleaseContext>;
+    protected defaultTuples: PluginTuple<PluginClass>[];
     /**
-     * Starting tag or commit reference
-     *
-     * Defines the start point for collecting commits.
-     * Can be a tag name, commit hash, or branch name.
-     *
-     * @example
-     * ```typescript
-     * from: 'v1.0.0'  // Start from v1.0.0 tag
-     * from: 'abc123'  // Start from specific commit
-     * ```
+     * Release context instance
+     * @protected
      */
-    from?: string;
+    protected context: ReleaseContext;
     /**
-     * Ending tag or commit reference
-     *
-     * Defines the end point for collecting commits.
-     * Can be a tag name, commit hash, or branch name.
+     * Creates a new ReleaseTask instance
      *
-     * @example
-     * ```typescript
-     * to: 'v2.0.0'    // End at v2.0.0 tag
-     * to: 'main'      // End at main branch
-     * ```
-     */
-    to?: string;
-    /**
-     * Directory to collect commits from
+     * Initializes the release context and sets up plugin configuration.
+     * Supports custom executors and plugin configurations.
      *
-     * Limits commit collection to changes in specified directory.
-     * Useful for monorepo package-specific changelogs.
+     * @param options - Release context configuration
+     * @param executor - Custom async executor (optional)
+     * @param defaultTuples - Plugin configuration tuples (optional)
      *
      * @example
      * ```typescript
-     * directory: 'packages/my-pkg'  // Only changes in this directory
+     * // Basic initialization
+     * const task = new ReleaseTask({
+     *   rootPath: '/path/to/project',
+     *   sourceBranch: 'main'
+     * });
+     *
+     * // With custom executor and plugins
+     * const task = new ReleaseTask(
+     *   { rootPath: '/path/to/project' },
+     *   new LifecycleExecutor<ReleaseContext>(),
+     *   [tuple(CustomPlugin, { option: 'value' })]
+     * );
      * ```
      */
-    directory?: string;
+    constructor(options?: Partial<ReleaseContextOptions>, executor?: LifecycleExecutor<ReleaseContext>, defaultTuples?: PluginTuple<PluginClass>[]);
     /**
-     * Git commit fields to include
+     * Gets the current release context
      *
-     * Specifies which Git commit fields to retrieve.
-     * @default ["abbrevHash", "hash", "subject", "authorName", "authorDate"]
+     * @returns Release context instance
      *
      * @example
      * ```typescript
-     * fields: ['hash', 'subject', 'authorName']
+     * const task = new ReleaseTask();
+     * const context = task.getContext();
+     *
+     * console.log(context.releaseEnv);
+     * console.log(context.sourceBranch);
      * ```
      */
-    fields?: CommitField[];
+    getContext(): ReleaseContext;
     /**
-     * Whether to exclude merge commits
+     * Loads and configures plugins for the release task
      *
-     * When true, merge commits are filtered out from the changelog.
-     * @default true
+     * Combines default and external plugins, initializes them with
+     * the current context, and configures special cases like the
+     * Workspaces plugin.
      *
-     * @example
+     * Plugin Loading Process:
+     * 1. Merge default and external plugins
+     * 2. Initialize plugins with context
+     * 3. Configure special plugins
+     * 4. Add plugins to executor
+     *
+     * @param externalTuples - Additional plugin configurations
+     * @returns Array of initialized plugins
+     *
+     * @example Basic usage
      * ```typescript
-     * noMerges: true  // Exclude merge commits
-     * noMerges: false // Include merge commits
+     * const task = new ReleaseTask();
+     * const plugins = await task.usePlugins();
      * ```
-     */
-    noMerges?: boolean;
-    /**
-     * Commit type configurations
-     *
-     * Defines how different commit types should be handled and
-     * formatted in the changelog.
      *
-     * @example
+     * @example Custom plugins
      * ```typescript
-     * types: [
-     *   { type: 'feat', section: '### Features' },
-     *   { type: 'fix', section: '### Bug Fixes' },
-     *   { type: 'chore', hidden: true }  // Skip chore commits
-     * ]
+     * const task = new ReleaseTask();
+     * const plugins = await task.usePlugins([
+     *   tuple(CustomPlugin, { option: 'value' })
+     * ]);
      * ```
      */
-    types?: {
-        type: string;
-        section?: string;
-        hidden?: boolean;
-    }[];
+    usePlugins(externalTuples?: PluginTuple<PluginClass>[]): Promise<ScriptPlugin<ScriptContext<any>, ScriptPluginProps>[]>;
     /**
-     * Template for formatting commit entries
-     *
-     * Supports variables from CommitValue properties and adds:
-     * - ${scopeHeader}: Formatted scope
-     * - ${commitLink}: Commit hash link
-     * - ${prLink}: PR number link
+     * Executes the release task
      *
-     * @default '\n- ${scopeHeader} ${commitlint.message} ${commitLink} ${prLink}'
+     * Internal method that runs the task through the executor.
+     * Preserves the context through the execution chain.
      *
-     * @example
-     * ```typescript
-     * formatTemplate: '* ${commitlint.message} (${commitLink})'
-     * ```
+     * @returns Execution result
+     * @internal
      */
-    formatTemplate?: string;
+    run(): Promise<unknown>;
     /**
-     * Whether to include commit message body
+     * Main entry point for executing the release task
      *
-     * When true, includes the full commit message body
-     * in the changelog entry.
+     * Checks environment conditions, loads plugins, and executes
+     * the release process. Supports additional plugin configuration
+     * at execution time.
      *
-     * @since 2.3.0
-     * @default false
+     * Environment Control:
+     * - Checks FE_RELEASE environment variable
+     * - Skips release if FE_RELEASE=false
      *
-     * @example
+     * @param externalTuples - Additional plugin configurations
+     * @returns Execution result
+     * @throws Error if release is skipped via environment variable
+     *
+     * @example Basic execution
      * ```typescript
-     * commitBody: true  // Include full commit message
+     * const task = new ReleaseTask();
+     * await task.exec();
      * ```
-     */
-    commitBody?: boolean;
-}
-/**
- * Parsed conventional commit data
- *
- * Represents a commit message parsed according to the
- * conventional commit specification.
- *
- * Format: type(scope): message
- *
- * @example
- * ```typescript
- * const commit: Commitlint = {
- *   type: 'feat',
- *   scope: 'api',
- *   message: 'add new endpoint',
- *   body: 'Adds support for new API endpoint\n\nBREAKING CHANGE: API format changed'
- * };
- * ```
- */
-interface Commitlint {
-    /** Commit type (e.g., 'feat', 'fix') */
-    type?: string;
-    /** Commit scope (e.g., 'api', 'core') */
-    scope?: string;
-    /** Main commit message */
-    message: string;
-    /**
-     * Commit message body with title removed
-     * @since 2.3.0
-     */
-    body?: string;
-}
-/**
- * Complete commit information
- *
- * Combines Git commit data, parsed conventional commit info,
- * and PR metadata into a single value object.
- *
- * @example
- * ```typescript
- * const commit: CommitValue = {
- *   base: {
- *     hash: 'abc123',
- *     subject: 'feat(api): new endpoint (#123)'
- *   },
- *   commitlint: {
- *     type: 'feat',
- *     scope: 'api',
- *     message: 'new endpoint'
- *   },
- *   commits: [],
- *   prNumber: '123'
- * };
- * ```
- */
-interface CommitValue {
-    /** Raw Git commit information */
-    base: BaseCommit;
-    /** Parsed conventional commit data */
-    commitlint: Commitlint;
-    /** Sub-commits (for merge commits) */
-    commits: CommitValue[];
-    /** Associated pull request number */
-    prNumber?: string;
-}
-/**
- * Interface for changelog formatting
- *
- * Defines the contract for classes that format commit data
- * into changelog entries.
- *
- * @example
- * ```typescript
- * class MarkdownFormatter implements ChangelogFormatter {
- *   format(commits: CommitValue[]): string[] {
- *     return commits.map(commit =>
- *       `- ${commit.commitlint.message} (#${commit.prNumber})`
- *     );
- *   }
- * }
- * ```
- */
-interface ChangelogFormatter {
-    /**
-     * Formats commits into changelog entries
      *
-     * @param commits - Array of commits to format
-     * @param options - Optional formatting options
-     * @returns Array of formatted changelog lines
-     */
-    format<Opt extends GitChangelogOptions>(commits: unknown[], options?: Opt): string[];
-}
-/**
- * Interface for changelog generation
- *
- * Defines the contract for classes that generate changelogs
- * from Git history.
- *
- * @example
- * ```typescript
- * class GitChangelog implements ChangeLogInterface {
- *   async getCommits(options?: GitChangelogOptions): Promise<CommitValue[]> {
- *     // Get commits from Git and parse them
- *     const commits = await gitlog(options);
- *     return commits.map(commit => ({
- *       base: commit,
- *       commitlint: parseCommit(commit.subject),
- *       commits: []
- *     }));
- *   }
- * }
- * ```
- */
-interface ChangeLogInterface {
-    /**
-     * Retrieves and parses Git commits
+     * @example With additional plugins
+     * ```typescript
+     * const task = new ReleaseTask();
+     * await task.exec([
+     *   tuple(CustomPlugin, { option: 'value' })
+     * ]);
+     * ```
      *
-     * @param options - Optional Git log options
-     * @returns Promise resolving to array of parsed commits
+     * @example Environment control
+     * ```typescript
+     * // Skip release
+     * process.env.FE_RELEASE = 'false';
+     *
+     * const task = new ReleaseTask();
+     * try {
+     *   await task.exec();
+     * } catch (e) {
+     *   if (e.message === 'Skip Release') {
+     *     console.log('Release skipped via environment variable');
+     *   }
+     * }
+     * ```
      */
-    getCommits(options?: GitChangelogOptions): Promise<CommitValue[]>;
+    exec(externalTuples?: PluginTuple<PluginClass>[]): Promise<unknown>;
 }
 
 /**
@@ -2187,6 +2841,7 @@ declare class GitChangelogFormatter implements ChangelogFormatter {
     protected options: Options & {
         shell: ShellInterface;
     };
+    protected templateEngine: TemplateEngine;
     /**
      * Creates a new GitChangelogFormatter instance
      *
@@ -2352,50 +3007,6 @@ declare class GitChangelogFormatter implements ChangelogFormatter {
     formatScope(scope: string): string;
 }
 
-/**
- * @module GithubChangelog
- * @description GitHub-specific changelog generation
- *
- * This module extends the base changelog functionality with
- * GitHub-specific features like PR linking, commit filtering
- * by directory, and workspace-aware changelog generation.
- *
- * Core Features:
- * - PR-aware commit gathering
- * - Directory-based filtering
- * - GitHub link generation
- * - Workspace changelog transformation
- * - Markdown formatting
- *
- * @example Basic usage
- * ```typescript
- * const changelog = new GithubChangelog({
- *   shell,
- *   logger,
- *   githubRootPath: 'https://github.com/org/repo'
- * }, githubManager);
- *
- * const commits = await changelog.getFullCommit({
- *   from: 'v1.0.0',
- *   directory: 'packages/pkg-a'
- * });
- * ```
- *
- * @example Workspace transformation
- * ```typescript
- * const workspaces = await changelog.transformWorkspace(
- *   [{ name: 'pkg-a', path: 'packages/a' }],
- *   context
- * );
- * // Adds formatted changelog to each workspace
- * ```
- */
-
-interface GithubChangelogProps extends GitChangelogProps {
-    mergePRcommit?: boolean;
-    githubRootPath?: string;
-}
-
 /**
  * @module PluginLoader
  * @description Dynamic plugin loading and instantiation
@@ -2752,4 +3363,4 @@ declare function factory<T, Args extends unknown[]>(Constructor: ConstructorType
  */
 declare function reduceOptions(opts: OptionValues, commonKey?: string): OptionValues;
 
-export { CHANGELOG_ALL_FIELDS, type ConstructorType, type DeepPartial, type ExecutorReleaseContext, GitChangelog, GitChangelogFormatter, type GitChangelogProps, type GithubChangelogProps, type Options, type PackageJson, type PluginClass, type PluginConstructorParams, type PluginTuple, type ReleaseConfig, ReleaseContext, type ReleaseContextOptions$1 as ReleaseContextOptions, ReleaseLabel, type ReleaseLabelCompare, type ReleaseLabelOptions, type ReleaseReturnValue, ReleaseTask, type StepOption, type TemplateContext, factory, load, loaderPluginsFromPluginTuples, reduceOptions, tuple };
+export { type BaseCommit, CHANGELOG_ALL_FIELDS, type ChangeLogInterface, type ChangelogFormatter, ChangesetVersion, type ChangesetVersionMode, type ChangesetVersionProps, type CommitTuple, type CommitValue, type Commitlint, type ConstructorType, type DeepPartial, type ExecutorReleaseContext, GitChangelog, GitChangelogFormatter, type GitChangelogOptions, type GitChangelogProps, MANIFEST_PATH, type Options, type PackageJson, type PluginClass, type PluginConstructorParams, type PluginTuple, type ReleaseConfig, ReleaseContext, type ReleaseContextOptions$1 as ReleaseContextOptions, type ReleaseGlobalConfig, ReleaseLabel, type ReleaseLabelCompare, type ReleaseLabelOptions, type ReleaseReturnValue, ReleaseTask, type StepOption, TEMPLATE_OPEN, type TemplateContext, type WorkspaceInterface, defaultReleaaseName, factory, load, loaderPluginsFromPluginTuples, reduceOptions, releaseJson, tuple };