@hyperfrontend/versioning 0.1.0 → 0.3.0

package/commits/classify/infrastructure.d.ts

@@ -0,0 +1,205 @@
+import type { GitCommit } from '../../git/models/commit';
+/**
+ * Context provided to infrastructure matchers for decision making.
+ *
+ * Contains information about a commit that helps determine
+ * whether it should be classified as infrastructure-related.
+ */
+export interface InfrastructureMatchContext {
+    /** The git commit being evaluated */
+    readonly commit: GitCommit;
+    /** Parsed conventional scope (convenience, may be undefined) */
+    readonly scope?: string;
+    /** Commit message subject */
+    readonly subject: string;
+    /** Full commit message */
+    readonly message: string;
+}
+/**
+ * Infrastructure matcher function type.
+ *
+ * Returns true if the commit should be classified as infrastructure-related.
+ * Matchers are composable - combine them using `anyOf`, `allOf`, and `not`.
+ *
+ * @example
+ * // Simple scope matcher
+ * const ciMatcher: InfrastructureMatcher = (ctx) => ctx.scope === 'ci'
+ *
+ * @example
+ * // Using factory functions
+ * const matcher = anyOf(
+ *   scopeMatcher(['ci', 'build', 'tooling']),
+ *   pathMatcher(['tools/', '.github/'])
+ * )
+ */
+export type InfrastructureMatcher = (context: InfrastructureMatchContext) => boolean;
+/**
+ * Configuration for building infrastructure commit sets.
+ *
+ * Supports multiple detection methods that can be combined:
+ * - Path-based: Commits touching specific file paths
+ * - Scope-based: Commits with specific conventional scopes
+ * - Custom matcher: User-provided matching logic
+ */
+export interface InfrastructureConfig {
+    /**
+     * File/directory paths that indicate infrastructure changes.
+     * Used to query git for commits touching these paths.
+     *
+     * @example ['tools/', '.github/workflows/', 'nx.json']
+     */
+    readonly paths?: readonly string[];
+    /**
+     * Conventional commit scopes that indicate infrastructure.
+     * Matched against parsed commit scope.
+     *
+     * @example ['ci', 'build', 'tooling', 'workspace']
+     */
+    readonly scopes?: readonly string[];
+    /**
+     * Custom matcher function for complex logic.
+     * Combined with paths/scopes using OR logic.
+     *
+     * @example (ctx) => ctx.message.includes('[infra]')
+     */
+    readonly matcher?: InfrastructureMatcher;
+}
+/**
+ * Creates a matcher that checks if commit scope matches any of the given scopes.
+ *
+ * @param scopes - Scopes to match against (case-insensitive)
+ * @returns Matcher that returns true if scope matches
+ *
+ * @example
+ * const matcher = scopeMatcher(['ci', 'build', 'tooling'])
+ * matcher({ scope: 'CI', ... }) // true
+ * matcher({ scope: 'feat', ... }) // false
+ */
+export declare function scopeMatcher(scopes: readonly string[]): InfrastructureMatcher;
+/**
+ * Creates a matcher that checks if commit scope starts with any of the given prefixes.
+ *
+ * @param prefixes - Scope prefixes to match (case-insensitive)
+ * @returns Matcher that returns true if scope starts with any prefix
+ *
+ * @example
+ * const matcher = scopePrefixMatcher(['tool-', 'infra-'])
+ * matcher({ scope: 'tool-package', ... }) // true
+ * matcher({ scope: 'lib-utils', ... }) // false
+ */
+export declare function scopePrefixMatcher(prefixes: readonly string[]): InfrastructureMatcher;
+/**
+ * Creates a matcher that checks if commit message contains any of the given patterns.
+ *
+ * @param patterns - Patterns to search for in commit message (case-insensitive)
+ * @returns Matcher that returns true if message contains any pattern
+ *
+ * @example
+ * const matcher = messageMatcher(['[infra]', '[ci skip]'])
+ */
+export declare function messageMatcher(patterns: readonly string[]): InfrastructureMatcher;
+/**
+ * Creates a matcher from a regex pattern tested against the scope.
+ *
+ * @param pattern - Regex pattern to test against scope
+ * @returns Matcher that returns true if scope matches regex
+ *
+ * @example
+ * const matcher = scopeRegexMatcher(/^(ci|build|tool)-.+/)
+ */
+export declare function scopeRegexMatcher(pattern: RegExp): InfrastructureMatcher;
+/**
+ * Combines matchers with OR logic - returns true if ANY matcher matches.
+ *
+ * @param matchers - Matchers to combine
+ * @returns Combined matcher
+ *
+ * @example
+ * const combined = anyOf(
+ *   scopeMatcher(['ci', 'build']),
+ *   messageMatcher(['[infra]']),
+ *   custom((ctx) => ctx.scope?.startsWith('tool-'))
+ * )
+ */
+export declare function anyOf(...matchers: readonly InfrastructureMatcher[]): InfrastructureMatcher;
+/**
+ * Combines matchers with AND logic - returns true if ALL matchers match.
+ *
+ * @param matchers - Matchers to combine
+ * @returns Combined matcher
+ *
+ * @example
+ * const combined = allOf(
+ *   scopeMatcher(['deps']),
+ *   messageMatcher(['security'])
+ * )
+ */
+export declare function allOf(...matchers: readonly InfrastructureMatcher[]): InfrastructureMatcher;
+/**
+ * Negates a matcher - returns true if matcher returns false.
+ *
+ * @param matcher - Matcher to negate
+ * @returns Negated matcher
+ *
+ * @example
+ * const notRelease = not(scopeMatcher(['release']))
+ */
+export declare function not(matcher: InfrastructureMatcher): InfrastructureMatcher;
+/**
+ * Matches common CI/CD scopes.
+ *
+ * Matches: ci, cd, build, pipeline, workflow, actions
+ */
+export declare const CI_SCOPE_MATCHER: InfrastructureMatcher;
+/**
+ * Matches common tooling/workspace scopes.
+ *
+ * Matches: tooling, workspace, monorepo, nx, root
+ */
+export declare const TOOLING_SCOPE_MATCHER: InfrastructureMatcher;
+/**
+ * Matches tool-prefixed scopes (e.g., tool-package, tool-scripts).
+ */
+export declare const TOOL_PREFIX_MATCHER: InfrastructureMatcher;
+/**
+ * Combined matcher for common infrastructure patterns.
+ *
+ * Combines CI, tooling, and tool-prefix matchers.
+ */
+export declare const DEFAULT_INFRA_SCOPE_MATCHER: InfrastructureMatcher;
+/**
+ * Builds a combined matcher from infrastructure configuration.
+ *
+ * Combines scope-based matching with any custom matcher using OR logic.
+ * Path-based matching is handled separately via git queries.
+ *
+ * @param config - Infrastructure configuration
+ * @returns Combined matcher, or null if no matchers configured
+ *
+ * @example
+ * const matcher = buildInfrastructureMatcher({
+ *   scopes: ['ci', 'build'],
+ *   matcher: (ctx) => ctx.scope?.startsWith('tool-')
+ * })
+ */
+export declare function buildInfrastructureMatcher(config: InfrastructureConfig): InfrastructureMatcher | null;
+/**
+ * Creates match context from a git commit.
+ *
+ * Extracts scope from conventional commit message if present.
+ *
+ * @param commit - Git commit to create context for
+ * @param scope - Pre-parsed scope (optional, saves re-parsing)
+ * @returns Match context for use with matchers
+ */
+export declare function createMatchContext(commit: GitCommit, scope?: string): InfrastructureMatchContext;
+/**
+ * Evaluates a commit against an infrastructure matcher.
+ *
+ * @param commit - Git commit to evaluate
+ * @param matcher - Matcher function to apply
+ * @param scope - Pre-parsed scope (optional)
+ * @returns True if commit matches infrastructure criteria
+ */
+export declare function evaluateInfrastructure(commit: GitCommit, matcher: InfrastructureMatcher, scope?: string): boolean;
+//# sourceMappingURL=infrastructure.d.ts.map

package/commits/classify/infrastructure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"infrastructure.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/versioning/src/commits/classify/infrastructure.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAGxD;;;;;GAKG;AACH,MAAM,WAAW,0BAA0B;IACzC,qCAAqC;IACrC,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAA;IAE1B,gEAAgE;IAChE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;IAEvB,6BAA6B;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IAExB,0BAA0B;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,OAAO,EAAE,0BAA0B,KAAK,OAAO,CAAA;AAEpF;;;;;;;GAOG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAElC;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAEnC;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,qBAAqB,CAAA;CACzC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,qBAAqB,CAM7E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,qBAAqB,CAOrF;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,qBAAqB,CAMjF;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,qBAAqB,CAKxE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,KAAK,CAAC,GAAG,QAAQ,EAAE,SAAS,qBAAqB,EAAE,GAAG,qBAAqB,CAE1F;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,KAAK,CAAC,GAAG,QAAQ,EAAE,SAAS,qBAAqB,EAAE,GAAG,qBAAqB,CAE1F;AAED;;;;;;;;GAQG;AACH,wBAAgB,GAAG,CAAC,OAAO,EAAE,qBAAqB,GAAG,qBAAqB,CAEzE;AAED;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,EAAE,qBAA8F,CAAA;AAE7H;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,EAAE,qBAAwF,CAAA;AAE5H;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,qBAAqD,CAAA;AAEvF;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,EAAE,qBAA2F,CAAA;AAErI;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,oBAAoB,GAAG,qBAAqB,GAAG,IAAI,CAqBrG;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,0BAA0B,CAOhG;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,qBAAqB,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAGjH"}

package/commits/classify/models.d.ts

@@ -0,0 +1,108 @@
+import type { GitCommit } from '../../git/models/commit';
+import type { ConventionalCommit } from '../models/conventional';
+/**
+ * Source of how a commit relates to a project.
+ *
+ * Classification determines whether a commit should appear in a
+ * project's changelog and how its scope should be displayed.
+ */
+export type CommitSource = 'direct-scope' | 'direct-file' | 'unscoped-file' | 'indirect-dependency' | 'indirect-infra' | 'unscoped-global' | 'excluded';
+/**
+ * A commit with classification metadata for changelog generation.
+ *
+ * Contains the original commit data plus attribution information
+ * that determines inclusion and presentation in changelogs.
+ */
+export interface ClassifiedCommit {
+    /** The parsed conventional commit */
+    readonly commit: ConventionalCommit;
+    /** The raw git commit (for hash, date, etc.) */
+    readonly raw: GitCommit;
+    /** How this commit relates to the project */
+    readonly source: CommitSource;
+    /** Whether to include this commit in changelog */
+    readonly include: boolean;
+    /** Whether to preserve scope in changelog output */
+    readonly preserveScope: boolean;
+    /** Files in this project touched by the commit (if applicable) */
+    readonly touchedFiles?: readonly string[];
+    /** Dependency chain if indirect (e.g., ['lib-utils'] for lib-app → lib-utils) */
+    readonly dependencyPath?: readonly string[];
+}
+/**
+ * Input for classification - a parsed commit with its raw git data.
+ */
+export interface CommitWithRaw {
+    /** The parsed conventional commit */
+    readonly commit: ConventionalCommit;
+    /** The raw git commit data */
+    readonly raw: GitCommit;
+}
+/**
+ * Classification context containing project and workspace info.
+ */
+export interface ClassificationContext {
+    /** Scopes that should be considered direct matches */
+    readonly projectScopes: readonly string[];
+    /** Set of commit hashes that touched project files */
+    readonly fileCommitHashes: ReadonlySet<string>;
+    /** Map of dependency name to set of commit hashes touching that dependency */
+    readonly dependencyCommitMap?: ReadonlyMap<string, ReadonlySet<string>>;
+    /**
+     * Set of commit hashes that touched infrastructure paths.
+     * These commits will be classified as 'indirect-infra'.
+     */
+    readonly infrastructureCommitHashes?: ReadonlySet<string>;
+    /** Scopes to always exclude */
+    readonly excludeScopes?: readonly string[];
+    /** Additional scopes to include as direct */
+    readonly includeScopes?: readonly string[];
+}
+/**
+ * Result of classifying multiple commits.
+ */
+export interface ClassificationResult {
+    /** All classified commits */
+    readonly commits: readonly ClassifiedCommit[];
+    /** Commits to include in changelog */
+    readonly included: readonly ClassifiedCommit[];
+    /** Commits excluded from changelog */
+    readonly excluded: readonly ClassifiedCommit[];
+    /** Summary statistics */
+    readonly summary: ClassificationSummary;
+}
+/**
+ * Summary statistics from classification.
+ */
+export interface ClassificationSummary {
+    /** Total commits processed */
+    readonly total: number;
+    /** Commits included in changelog */
+    readonly included: number;
+    /** Commits excluded from changelog */
+    readonly excluded: number;
+    /** Breakdown by source type */
+    readonly bySource: Readonly<Record<CommitSource, number>>;
+}
+/**
+ * Creates an empty classification summary.
+ *
+ * @returns A new ClassificationSummary with all counts at zero
+ */
+export declare function createEmptyClassificationSummary(): ClassificationSummary;
+/**
+ * Creates a classified commit.
+ *
+ * @param commit - The parsed conventional commit
+ * @param raw - The raw git commit
+ * @param source - How the commit relates to the project
+ * @param options - Additional classification options
+ * @param options.touchedFiles - Files in the project modified by this commit
+ * @param options.dependencyPath - Chain of dependencies leading to indirect inclusion
+ * @returns A new ClassifiedCommit object
+ */
+export declare function createClassifiedCommit(commit: ConventionalCommit, raw: GitCommit, source: CommitSource, options?: {
+    readonly touchedFiles?: readonly string[];
+    readonly dependencyPath?: readonly string[];
+}): ClassifiedCommit;
+//# sourceMappingURL=models.d.ts.map

package/commits/classify/models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/versioning/src/commits/classify/models.ts"],"names":[],"mappings":"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"}

package/commits/classify/project-scopes.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Options for deriving project scopes.
+ */
+export interface DeriveProjectScopesOptions {
+    /** The project name (e.g., 'lib-versioning') */
+    readonly projectName: string;
+    /** The npm package name (e.g., '@hyperfrontend/versioning') */
+    readonly packageName?: string;
+    /** Additional scopes to include */
+    readonly additionalScopes?: readonly string[];
+    /**
+     * Project name prefixes to strip for scope matching.
+     *
+     * @default DEFAULT_PROJECT_PREFIXES
+     */
+    readonly prefixes?: readonly string[];
+}
+/**
+ * Derives all scope variations that should match a project.
+ *
+ * Given a project named 'lib-versioning' with package '@hyperfrontend/versioning',
+ * this generates variations like:
+ * - 'lib-versioning' (full project name)
+ * - 'versioning' (without lib- prefix)
+ *
+ * @param options - Project identification options
+ * @returns Array of scope strings that match this project
+ *
+ * @example
+ * deriveProjectScopes({ projectName: 'lib-versioning', packageName: '@hyperfrontend/versioning' })
+ * // Returns: ['lib-versioning', 'versioning']
+ *
+ * @example
+ * deriveProjectScopes({ projectName: 'app-demo', packageName: 'demo-app' })
+ * // Returns: ['app-demo', 'demo']
+ */
+export declare function deriveProjectScopes(options: DeriveProjectScopesOptions): readonly string[];
+/**
+ * Default project name prefixes that can be stripped for scope matching.
+ */
+export declare const DEFAULT_PROJECT_PREFIXES: readonly ["lib-", "app-", "e2e-", "tool-", "plugin-", "feature-", "package-"];
+/**
+ * Checks if a commit scope matches any of the project scopes.
+ *
+ * @param commitScope - The scope from a conventional commit
+ * @param projectScopes - Array of scopes that match the project
+ * @returns True if the commit scope matches the project
+ *
+ * @example
+ * scopeMatchesProject('versioning', ['lib-versioning', 'versioning']) // true
+ * scopeMatchesProject('logging', ['lib-versioning', 'versioning']) // false
+ */
+export declare function scopeMatchesProject(commitScope: string | undefined, projectScopes: readonly string[]): boolean;
+/**
+ * Checks if a commit scope should be explicitly excluded.
+ *
+ * @param commitScope - The scope from a conventional commit
+ * @param excludeScopes - Array of scopes to exclude
+ * @returns True if the scope should be excluded
+ */
+export declare function scopeIsExcluded(commitScope: string | undefined, excludeScopes: readonly string[]): boolean;
+/**
+ * Default scopes to exclude from changelogs.
+ *
+ * These represent repository-level or infrastructure changes
+ * that typically don't belong in individual project changelogs.
+ */
+export declare const DEFAULT_EXCLUDE_SCOPES: readonly string[];
+//# sourceMappingURL=project-scopes.d.ts.map

package/commits/classify/project-scopes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-scopes.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/versioning/src/commits/classify/project-scopes.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,gDAAgD;IAChD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAE5B,+DAA+D;IAC/D,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;IAE7B,mCAAmC;IACnC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAE7C;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CACtC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,0BAA0B,GAAG,SAAS,MAAM,EAAE,CA6B1F;AAED;;GAEG;AACH,eAAO,MAAM,wBAAwB,+EAA8E,CAAA;AAmDnH;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,EAAE,aAAa,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAQ9G;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,EAAE,aAAa,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAO1G;AAED;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,EAAE,SAAS,MAAM,EAAoE,CAAA"}