@hyperfrontend/versioning 0.2.0 → 0.3.0

package/flow/index.cjs.js

@@ -137,12 +137,12 @@ const createSet = (iterable) => _Reflect$4.construct(_Set, iterable ? [iterable]
  * // Returns: ['app-demo', 'demo']
  */
 function deriveProjectScopes(options) {
-    const { projectName, packageName, additionalScopes = [] } = options;
+    const { projectName, packageName, additionalScopes = [], prefixes = DEFAULT_PROJECT_PREFIXES } = options;
     const scopes = createSet();
     // Always include the full project name
     scopes.add(projectName);
     // Add variations based on common prefixes
-    const prefixVariations = extractPrefixVariations(projectName);
+    const prefixVariations = extractPrefixVariations(projectName, prefixes);
     for (const variation of prefixVariations) {
         scopes.add(variation);
     }
@@ -162,18 +162,19 @@ function deriveProjectScopes(options) {
     return [...scopes];
 }
 /**
- * Recognized project name prefixes that can be stripped for scope matching.
+ * Default project name prefixes that can be stripped for scope matching.
  */
-const PROJECT_PREFIXES = ['lib-', 'app-', 'e2e-', 'tool-', 'plugin-', 'feature-', 'package-'];
+const DEFAULT_PROJECT_PREFIXES = ['lib-', 'app-', 'e2e-', 'tool-', 'plugin-', 'feature-', 'package-'];
 /**
  * Generates scope variations by stripping recognized project prefixes.
  *
  * @param projectName - The project name to extract variations from
+ * @param prefixes - Prefixes to check and strip
  * @returns Array of scope name variations
  */
-function extractPrefixVariations(projectName) {
+function extractPrefixVariations(projectName, prefixes) {
     const variations = [];
-    for (const prefix of PROJECT_PREFIXES) {
+    for (const prefix of prefixes) {
         if (projectName.startsWith(prefix)) {
             const withoutPrefix = projectName.slice(prefix.length);
             if (withoutPrefix) {
@@ -593,6 +594,10 @@ function createMatchContext(commit, scope) {
     };
 }
 
+/**
+ * Default changelog filename.
+ */
+const DEFAULT_CHANGELOG_FILENAME = 'CHANGELOG.md';
 /**
  * Default scope filtering configuration.
  *
@@ -604,6 +609,7 @@ const DEFAULT_SCOPE_FILTERING_CONFIG = {
     includeScopes: [],
     excludeScopes: DEFAULT_EXCLUDE_SCOPES,
     trackDependencyChanges: false,
+    projectPrefixes: DEFAULT_PROJECT_PREFIXES,
     infrastructure: undefined,
     infrastructureMatcher: undefined,
 };
@@ -627,8 +633,11 @@ const DEFAULT_FLOW_CONFIG = {
     allowPrerelease: false,
     prereleaseId: 'alpha',
     releaseAs: undefined,
+    maxCommitFallback: 500,
     repository: undefined,
     scopeFiltering: DEFAULT_SCOPE_FILTERING_CONFIG,
+    changelogFileName: DEFAULT_CHANGELOG_FILENAME,
+    commitTypeToSection: undefined,
 };
 
 /**
@@ -8187,6 +8196,7 @@ const ANALYZE_COMMITS_STEP_ID = 'analyze-commits';
 function createAnalyzeCommitsStep() {
     return createStep(ANALYZE_COMMITS_STEP_ID, 'Analyze Commits', async (ctx) => {
         const { git, projectName, projectRoot, packageName, workspaceRoot, config, logger, state } = ctx;
+        const maxFallback = config.maxCommitFallback ?? 500;
         // Use publishedCommit from registry (set by fetch-registry step)
         const { publishedCommit, isFirstRelease } = state;
         let rawCommits;
@@ -8203,13 +8213,13 @@ function createAnalyzeCommitsStep() {
                 logger.warn(`Published commit ${publishedCommit.slice(0, 7)} not found in history. ` +
                     `This may indicate a rebase or force push occurred after publishing v${state.publishedVersion}. ` +
                     `Falling back to recent commit analysis.`);
-                rawCommits = git.getCommitLog({ maxCount: 100 });
+                rawCommits = git.getCommitLog({ maxCount: maxFallback });
                 // effectiveBaseCommit stays null - no compare URL will be generated
             }
         }
         else {
             // First release or no published version
-            rawCommits = git.getCommitLog({ maxCount: 100 });
+            rawCommits = git.getCommitLog({ maxCount: maxFallback });
             logger.debug(`First release - analyzing up to ${rawCommits.length} commits`);
         }
         // Get scope filtering configuration
@@ -8251,7 +8261,7 @@ function createAnalyzeCommitsStep() {
             const relativePath = getRelativePath(workspaceRoot, projectRoot);
             const pathFilteredCommits = effectiveBaseCommit
                 ? git.getCommitsSince(effectiveBaseCommit, { path: relativePath })
-                : git.getCommitLog({ maxCount: 100, path: relativePath });
+                : git.getCommitLog({ maxCount: maxFallback, path: relativePath });
             fileCommitHashes = createSet(pathFilteredCommits.map((c) => c.hash));
             logger.debug(`Found ${fileCommitHashes.size} commits touching ${relativePath}`);
         }
@@ -8260,14 +8270,15 @@ function createAnalyzeCommitsStep() {
             projectName,
             packageName,
             additionalScopes: scopeFilteringConfig.includeScopes,
+            prefixes: scopeFilteringConfig.projectPrefixes,
         });
         logger.debug(`Project scopes: ${projectScopes.join(', ')}`);
         // Build infrastructure commit hashes for file-based infrastructure detection
-        const infrastructureCommitHashes = buildInfrastructureCommitHashes(git, effectiveBaseCommit, rawCommits, parsedCommits, scopeFilteringConfig, logger);
+        const infrastructureCommitHashes = buildInfrastructureCommitHashes(git, effectiveBaseCommit, rawCommits, parsedCommits, scopeFilteringConfig, logger, maxFallback);
         // Build dependency commit map if tracking is enabled (Phase 4)
         let dependencyCommitMap;
         if (scopeFilteringConfig.trackDependencyChanges) {
-            dependencyCommitMap = buildDependencyCommitMap(git, workspaceRoot, projectName, effectiveBaseCommit, logger);
+            dependencyCommitMap = buildDependencyCommitMap(git, workspaceRoot, projectName, effectiveBaseCommit, logger, maxFallback);
         }
         // Create classification context
         const classificationContext = createClassificationContext(projectScopes, fileCommitHashes, {
@@ -8400,9 +8411,10 @@ function buildSummaryMessage(includedCount, totalCount, summary, strategy) {
  * @param config - Scope filtering configuration
  * @param logger - Logger with debug method for output
  * @param logger.debug - Debug logging function
+ * @param maxFallback - Maximum commits to query when baseCommit is null
  * @returns Set of commit hashes classified as infrastructure
  */
-function buildInfrastructureCommitHashes(git, baseCommit, rawCommits, parsedCommits, config, logger) {
+function buildInfrastructureCommitHashes(git, baseCommit, rawCommits, parsedCommits, config, logger, maxFallback) {
     // Collect all infrastructure commit hashes
     let infraHashes = createSet();
     // Method 1: Path-based detection (query git for commits touching infra paths)
@@ -8411,7 +8423,7 @@ function buildInfrastructureCommitHashes(git, baseCommit, rawCommits, parsedComm
         for (const infraPath of infraPaths) {
             const pathCommits = baseCommit
                 ? git.getCommitsSince(baseCommit, { path: infraPath })
-                : git.getCommitLog({ maxCount: 100, path: infraPath });
+                : git.getCommitLog({ maxCount: maxFallback, path: infraPath });
             for (const commit of pathCommits) {
                 infraHashes = infraHashes.add(commit.hash);
             }
@@ -8479,9 +8491,10 @@ function combineMatcher(a, b) {
  * @param baseCommit - Base commit hash for commit range (null for first release/fallback)
  * @param logger - Logger with debug method for output
  * @param logger.debug - Debug logging function
+ * @param maxFallback - Maximum commits to query when baseCommit is null
  * @returns Map of dependency names to commit hashes touching that dependency
  */
-function buildDependencyCommitMap(git, workspaceRoot, projectName, baseCommit, logger) {
+function buildDependencyCommitMap(git, workspaceRoot, projectName, baseCommit, logger, maxFallback) {
     let dependencyMap = createMap();
     try {
         // Discover all projects in workspace using lib-project-scope
@@ -8506,7 +8519,7 @@ function buildDependencyCommitMap(git, workspaceRoot, projectName, baseCommit, l
             // Query git for commits touching this dependency's path
             const depCommits = baseCommit
                 ? git.getCommitsSince(baseCommit, { path: depRoot })
-                : git.getCommitLog({ maxCount: 100, path: depRoot });
+                : git.getCommitLog({ maxCount: maxFallback, path: depRoot });
             if (depCommits.length > 0) {
                 const hashSet = createSet(depCommits.map((c) => c.hash));
                 dependencyMap = dependencyMap.set(dep.target, hashSet);
@@ -10147,11 +10160,22 @@ function isWhitespace(char) {
 }
 
 /**
- * Changelog Parser
+ * Validates that a URL is actually a GitHub URL by parsing it properly.
+ * This prevents SSRF attacks where 'github.com' could appear in path/query.
  *
- * Parses a changelog markdown string into a structured Changelog object.
- * Uses a state machine tokenizer for ReDoS-safe parsing.
+ * @param url - The URL string to validate
+ * @returns True if the URL host is github.com or a subdomain
  */
+function isGitHubUrl(url) {
+    try {
+        const parsed = createURL(url);
+        // Check that the host is exactly github.com or ends with .github.com
+        return parsed.host === 'github.com' || parsed.host.endsWith('.github.com');
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Parses a changelog markdown string into a Changelog object.
  *
@@ -10219,7 +10243,7 @@ function parseHeader(state) {
                 description.push(`[${token.value}](${nextToken.value})`);
                 links.push({ label: token.value, url: nextToken.value });
                 // Try to detect repository URL
-                if (!state.repositoryUrl && nextToken.value.includes('github.com')) {
+                if (!state.repositoryUrl && isGitHubUrl(nextToken.value)) {
                     state.repositoryUrl = extractRepoUrl(nextToken.value);
                 }
                 advance(state); // skip link-text
@@ -11021,7 +11045,7 @@ const GENERATE_CHANGELOG_STEP_ID = 'generate-changelog';
 /**
  * Maps conventional commit types to changelog section types.
  */
-const COMMIT_TYPE_TO_SECTION = {
+const DEFAULT_COMMIT_TYPE_TO_SECTION = {
     feat: 'features',
     fix: 'fixes',
     perf: 'performance',
@@ -11034,6 +11058,18 @@ const COMMIT_TYPE_TO_SECTION = {
     chore: 'chores',
     style: 'other',
 };
+/**
+ * Resolves the commit type to section mapping by merging config with defaults.
+ *
+ * @param configMapping - User-provided partial mapping from FlowConfig
+ * @returns Resolved mapping with user overrides applied
+ */
+function resolveCommitTypeMapping(configMapping) {
+    if (!configMapping) {
+        return DEFAULT_COMMIT_TYPE_TO_SECTION;
+    }
+    return { ...DEFAULT_COMMIT_TYPE_TO_SECTION, ...configMapping };
+}
 /**
  * Checks if a commit source represents an indirect change.
  *
@@ -11047,16 +11083,22 @@ function isIndirectSource(source) {
  * Groups classified commits by their section type.
  *
  * @param commits - Array of classified commits
+ * @param mapping - Commit type to section mapping
  * @returns Record of section type to classified commits
  */
-function groupClassifiedCommitsBySection(commits) {
+function groupClassifiedCommitsBySection(commits, mapping) {
     const groups = {};
     for (const classified of commits) {
-        const sectionType = COMMIT_TYPE_TO_SECTION[classified.commit.type ?? 'chore'] ?? 'chores';
-        if (!groups[sectionType]) {
-            groups[sectionType] = [];
+        const sectionType = mapping[classified.commit.type ?? 'chore'];
+        // Skip if explicitly excluded (null)
+        if (sectionType === null)
+            continue;
+        // Fallback to 'chores' for unmapped types
+        const resolvedSection = sectionType ?? 'chores';
+        if (!groups[resolvedSection]) {
+            groups[resolvedSection] = [];
         }
-        groups[sectionType].push(classified);
+        groups[resolvedSection].push(classified);
     }
     return groups;
 }
@@ -11064,16 +11106,22 @@ function groupClassifiedCommitsBySection(commits) {
  * Groups commits by their section type.
  *
  * @param commits - Array of conventional commits
+ * @param mapping - Commit type to section mapping
  * @returns Record of section type to commits
  */
-function groupCommitsBySection(commits) {
+function groupCommitsBySection(commits, mapping) {
     const groups = {};
     for (const commit of commits) {
-        const sectionType = COMMIT_TYPE_TO_SECTION[commit.type ?? 'chore'] ?? 'chores';
-        if (!groups[sectionType]) {
-            groups[sectionType] = [];
+        const sectionType = mapping[commit.type ?? 'chore'];
+        // Skip if explicitly excluded (null)
+        if (sectionType === null)
+            continue;
+        // Fallback to 'chores' for unmapped types
+        const resolvedSection = sectionType ?? 'chores';
+        if (!groups[resolvedSection]) {
+            groups[resolvedSection] = [];
         }
-        groups[sectionType].push(commit);
+        groups[resolvedSection].push(commit);
     }
     return groups;
 }
@@ -11141,6 +11189,8 @@ function createGenerateChangelogStep() {
     return createStep(GENERATE_CHANGELOG_STEP_ID, 'Generate Changelog Entry', async (ctx) => {
         const { config, state } = ctx;
         const { commits, nextVersion, bumpType } = state;
+        // Resolve commit type to section mapping
+        const commitTypeMapping = resolveCommitTypeMapping(config.commitTypeToSection);
         // Skip if no bump needed
         if (!nextVersion || bumpType === 'none') {
             return createSkippedResult('No version bump, skipping changelog generation');
@@ -11202,7 +11252,7 @@ function createGenerateChangelogStep() {
                 })));
             }
             // Group direct commits by section
-            const groupedDirect = groupClassifiedCommitsBySection(directCommits);
+            const groupedDirect = groupClassifiedCommitsBySection(directCommits, commitTypeMapping);
             // Add other sections in conventional order (direct commits only)
             const sectionOrder = [
                 { type: 'features', heading: 'Features' },
@@ -11230,7 +11280,7 @@ function createGenerateChangelogStep() {
         }
         else {
             // Fallback: use commits without classification (backward compatibility)
-            const grouped = groupCommitsBySection(commits);
+            const grouped = groupCommitsBySection(commits, commitTypeMapping);
             // Add breaking changes section first if any
             const breakingCommits = commits.filter((c) => c.breaking);
             if (breakingCommits.length > 0) {
@@ -11306,14 +11356,15 @@ function createWriteChangelogStep() {
         if (!nextVersion || bumpType === 'none' || !changelogEntry || config.skipChangelog) {
             return createSkippedResult('No changelog to write');
         }
-        const changelogPath = `${projectRoot}/CHANGELOG.md`;
+        const changelogFileName = config.changelogFileName ?? DEFAULT_CHANGELOG_FILENAME;
+        const changelogPath = `${projectRoot}/${changelogFileName}`;
         let existingContent = '';
         // Read existing changelog
         try {
             existingContent = tree.read(changelogPath, 'utf-8') ?? '';
         }
         catch {
-            logger.debug('No existing CHANGELOG.md found');
+            logger.debug(`No existing ${changelogFileName} found`);
         }
         // If no existing content, create new changelog
         if (!existingContent.trim()) {
@@ -11331,7 +11382,7 @@ function createWriteChangelogStep() {
                 stateUpdates: {
                     modifiedFiles: [...(state.modifiedFiles ?? []), changelogPath],
                 },
-                message: `Created CHANGELOG.md with version ${nextVersion}`,
+                message: `Created ${changelogFileName} with version ${nextVersion}`,
             };
         }
         // Parse existing and add entry
@@ -11365,7 +11416,7 @@ function createWriteChangelogStep() {
             stateUpdates: {
                 modifiedFiles: [...(state.modifiedFiles ?? []), changelogPath],
             },
-            message: `Updated CHANGELOG.md with version ${nextVersion}`,
+            message: `Updated ${changelogFileName} with version ${nextVersion}`,
         };
     }, {
         dependsOn: ['generate-changelog'],
@@ -12210,6 +12261,8 @@ exports.CALCULATE_BUMP_STEP_ID = CALCULATE_BUMP_STEP_ID;
 exports.CONVENTIONAL_FLOW_CONFIG = CONVENTIONAL_FLOW_CONFIG;
 exports.CREATE_COMMIT_STEP_ID = CREATE_COMMIT_STEP_ID;
 exports.CREATE_TAG_STEP_ID = CREATE_TAG_STEP_ID;
+exports.DEFAULT_CHANGELOG_FILENAME = DEFAULT_CHANGELOG_FILENAME;
+exports.DEFAULT_COMMIT_TYPE_TO_SECTION = DEFAULT_COMMIT_TYPE_TO_SECTION;
 exports.DEFAULT_FLOW_CONFIG = DEFAULT_FLOW_CONFIG;
 exports.FETCH_REGISTRY_STEP_ID = FETCH_REGISTRY_STEP_ID;
 exports.GENERATE_CHANGELOG_STEP_ID = GENERATE_CHANGELOG_STEP_ID;