@muverse/core 0.1.0

package/dist/git/index.js

@@ -0,0 +1,581 @@
+/**
+ * Git operations module for μVERSE version management.
+ * Provides interfaces for commit analysis, tagging, and conventional commit parsing.
+ * Supports monorepo and multi-module projects with module-specific tag management.
+ */
+import { CommitParser } from "conventional-commits-parser";
+import { logger } from "../utils/logger.js";
+import { execa } from "execa";
+/**
+ * Shared CommitParser instance for parsing conventional commits.
+ * Reused across all commit parsing operations to avoid repeated instantiation.
+ */
+const commitParser = new CommitParser({
+    breakingHeaderPattern: /^(\w*)(?:\(([\w$@.\-*/ ]*)\))?!: (.*)$/,
+});
+/**
+ * Retrieves all commits for a module since its last release tag.
+ * Handles monorepo and single-repo scenarios with path filtering.
+ * @param modulePath - Relative path to module from repository root (use '.' for root)
+ * @param moduleName - Module name used for tag searching
+ * @param moduleType - 'root' for general tags, 'module' for module-specific tags
+ * @param options - Git operation options
+ * @param excludePaths - Paths to exclude using git pathspec syntax
+ * @returns Promise resolving to array of parsed commits (oldest to newest)
+ */
+export async function getCommitsSinceLastTag(modulePath, moduleName, moduleType, options = {}, excludePaths = []) {
+    // Resolve the working directory, defaulting to current process directory
+    const cwd = options.cwd || process.cwd();
+    try {
+        // Find the most recent tag for this module
+        // For root modules, this finds general tags (v1.0.0)
+        // For submodules, this finds module-specific tags (module@1.0.0)
+        const lastTag = await getLastTagForModule(moduleName, moduleType, { cwd });
+        // Build the git revision range
+        // If tag exists: 'tag..HEAD' means commits after tag up to HEAD
+        // If no tag: empty string means all commits in history
+        const range = lastTag ? `${lastTag}..HEAD` : "";
+        return getCommitsInRange(range, modulePath, { cwd }, excludePaths);
+    }
+    catch (error) {
+        // If tag lookup fails for any reason, fall back to all commits
+        // This ensures we always have commit history for version determination
+        return getCommitsInRange("", modulePath, { cwd }, excludePaths);
+    }
+}
+/**
+ * Retrieves commits within a specific git revision range with path filtering.
+ * Uses git's native pathspec syntax for efficient filtering in monorepos.
+ * @param range - Git revision range (e.g., 'tag1..tag2', 'tag..HEAD', or '' for all)
+ * @param pathFilter - Optional path to filter commits (use '.' for root)
+ * @param options - Git operation options
+ * @param excludePaths - Paths to exclude using ':(exclude)path' syntax
+ * @returns Promise resolving to array of parsed commits (oldest to newest)
+ */
+export async function getCommitsInRange(range, pathFilter, options = {}, excludePaths = []) {
+    // Resolve working directory, defaulting to current directory
+    const cwd = options.cwd || process.cwd();
+    try {
+        // Build git log command with custom format for easy parsing
+        // Format: hash, subject, body, delimiter
+        const args = ["log", "--format=%H%n%s%n%b%n---COMMIT-END---"];
+        // Only add range if it's not empty
+        // Empty range means "all commits" which is valid
+        if (range.trim()) {
+            args.push(range);
+        }
+        // Add pathspec separator ('--') if we have paths or excludes
+        // This separates revision arguments from path arguments
+        // Add path filter if provided and not root
+        if (pathFilter && pathFilter !== ".") {
+            args.push("--", pathFilter);
+        }
+        else if (excludePaths.length > 0) {
+            // For root path, we still need to add the pathspec separator
+            // when we have exclude patterns
+            args.push("--");
+        }
+        // Add each exclude pattern using git's pathspec syntax
+        // :(exclude)path tells git to ignore commits touching that path
+        for (const excludePath of excludePaths) {
+            if (excludePath && excludePath !== ".") {
+                args.push(`:(exclude)${excludePath}`);
+            }
+        }
+        // Execute git log command
+        // Silent mode prevents output pollution in GitHub Actions
+        const { stdout } = await execa("git", args, { cwd });
+        // Parse the formatted output into CommitInfo objects
+        return parseGitLog(stdout);
+    }
+    catch (error) {
+        // Non-throwing error handling: log warning and return empty array
+        // This allows the system to continue even if git operations fail
+        logger.warning(`Warning: Failed to get git commits: ${error}`);
+        return [];
+    }
+}
+/**
+ * Parses raw git log output into structured CommitInfo objects with Conventional Commits analysis.
+ * Resilient to parsing failures - classifies non-conventional commits as 'unknown' type.
+ * @param output - Raw git log output using custom format
+ * @returns Array of parsed CommitInfo objects (empty if no valid commits)
+ * @internal
+ */
+function parseGitLog(output) {
+    // Early return for empty output - no commits to parse
+    if (!output.trim()) {
+        return [];
+    }
+    logger.debug(`Raw git log output:\n${output}`);
+    const commits = [];
+    // Split output into individual commit blocks using custom delimiter
+    // Filter removes empty blocks (trailing delimiters, etc.)
+    const commitBlocks = output
+        .split("---COMMIT-END---")
+        .filter((block) => block.trim());
+    for (const block of commitBlocks) {
+        // Split block into lines: [hash, subject, body...]
+        const lines = block.trim().split("\n");
+        // Skip malformed blocks (need at least hash and subject)
+        if (lines.length < 2) {
+            logger.debug(`Skipping malformed commit block:\n${block}`);
+            continue;
+        }
+        // Extract structured data from the block
+        const hash = lines[0]; // Line 1: commit SHA
+        const subject = lines[1]; // Line 2: commit message subject
+        const body = lines.slice(2).join("\n").trim(); // Remaining: commit body
+        logger.debug(`Processing commit ${hash} with subject: ${subject}`);
+        logger.debug(`Commit body:\n${body}`);
+        try {
+            // Parse using Conventional Commits specification
+            // Combines subject and body for full context (breaking changes may be in body)
+            const parsed = commitParser.parse(subject + "\n\n" + body);
+            logger.debug(`Parsed commit ${hash}: ${JSON.stringify(parsed)}`);
+            // Build CommitInfo from parsed data
+            commits.push({
+                hash,
+                type: parsed.type || "unknown", // Default to 'unknown' if type missing
+                scope: parsed.scope || undefined,
+                subject: parsed.subject || subject, // Fallback to raw subject if parsing fails
+                body: body || undefined,
+                // Check if any note has title 'BREAKING CHANGE'
+                breaking: parsed.notes?.some((note) => note.title === "BREAKING CHANGE") ||
+                    false,
+            });
+        }
+        catch (error) {
+            // If conventional commits parsing fails, treat as unknown type
+            // This ensures non-conventional commits don't break the system
+            commits.push({
+                hash,
+                type: "unknown",
+                subject,
+                body: body || undefined,
+                breaking: false,
+            });
+        }
+    }
+    return commits;
+}
+/**
+ * Finds the most recent git tag for a specific module with fallback to general tags.
+ * Searches module-specific tags first (moduleName@*), then falls back to general tags.
+ * @param moduleName - Module name for tag pattern construction
+ * @param moduleType - 'root' skips module tags, 'module' tries module tags first
+ * @param options - Git operation options
+ * @returns Most recent tag name or null if no tags exist
+ */
+export async function getLastTagForModule(moduleName, moduleType, options = {}) {
+    // Resolve working directory, defaulting to current directory
+    const cwd = options.cwd || process.cwd();
+    try {
+        // Generate glob pattern for module-specific tags (e.g., 'api@*')
+        const moduleTagPattern = getModuleTagPattern(moduleName);
+        // Only search for module-specific tags if it's not root
+        // Root projects use general tags (v1.0.0) rather than module tags (root@1.0.0)
+        if (moduleType !== "root") {
+            // Search for module-specific tags with version sorting
+            // --sort=-version:refname: Sort by version in descending order (newest first)
+            const { stdout } = await execa("git", ["tag", "-l", moduleTagPattern, "--sort=-version:refname"], {
+                cwd,
+            });
+            // If we found module-specific tags, return the first (most recent)
+            if (stdout.trim()) {
+                return stdout.trim().split("\n")[0];
+            }
+        }
+        // Fallback to general tags when:
+        // 1. Module type is 'root', or
+        // 2. No module-specific tags were found
+        try {
+            // git describe finds the most recent tag reachable from HEAD
+            // --tags: Consider all tags (not just annotated)
+            // --abbrev=0: Don't show commit hash suffix
+            const { stdout: fallbackOutput } = await execa("git", ["describe", "--tags", "--abbrev=0", "HEAD"], {
+                cwd,
+            });
+            return fallbackOutput.trim();
+        }
+        catch {
+            // If no tags at all, return null
+            // This typically means it's a new repository or no releases yet
+            return null;
+        }
+    }
+    catch (error) {
+        // Catch-all error handler: return null if any unexpected error occurs
+        // This makes the function non-throwing, which is safer for version calculations
+        return null;
+    }
+}
+/**
+ * Retrieves all git tags in the repository with parsed metadata.
+ * Returns array with tag name, commit hash, and parsed module/version information.
+ * @param options - Git operation options
+ * @returns Promise resolving to array of GitTag objects (empty array if no tags exist)
+ */
+export async function getAllTags(options = {}) {
+    // Resolve working directory
+    const cwd = options.cwd || process.cwd();
+    try {
+        // List all tags with custom format to get name and commit hash
+        // %(refname:short): Tag name without refs/tags/ prefix
+        // %(objectname): Full commit SHA that the tag points to
+        const { stdout } = await execa("git", ["tag", "-l", "--format=%(refname:short) %(objectname)"], {
+            cwd,
+        });
+        // Parse each line into a GitTag object
+        return stdout
+            .trim()
+            .split("\n")
+            .filter((line) => line.trim()) // Remove empty lines
+            .map((line) => {
+            // Each line format: "tagname commithash"
+            const [name, hash] = line.split(" ");
+            // Parse tag name to extract module and version (if present)
+            const { module, version } = parseTagName(name);
+            // Return structured tag object
+            return {
+                name,
+                hash,
+                module,
+                version,
+            };
+        });
+    }
+    catch (error) {
+        // Non-throwing: return empty array if git command fails
+        // This could happen if not in a git repository or no tags exist
+        return [];
+    }
+}
+/**
+ * Creates an annotated git tag at the current HEAD commit.
+ * Annotated tags include tagger metadata, date, message, and can be GPG signed.
+ * @param tagName - The tag name (e.g., 'core@1.0.0' or 'v1.0.0'). Must not already exist
+ * @param message - The annotation message for the tag
+ * @param options - Git operation options
+ * @returns Promise that resolves when the tag is successfully created
+ * @throws {Error} If tag creation fails (tag exists, invalid name, etc.)
+ */
+export async function createTag(tagName, message, options = {}) {
+    // Resolve working directory
+    const cwd = options.cwd || process.cwd();
+    try {
+        // Create annotated tag with message
+        // -a: Create an annotated tag (full git object)
+        // -m: Provide tag message inline
+        await execa("git", ["tag", "-a", tagName, "-m", message], { cwd });
+    }
+    catch (error) {
+        // Wrap error with more context for debugging
+        // Common failures: tag exists, no git repo, no user config
+        throw new Error(`Failed to create tag ${tagName}: ${error}`);
+    }
+}
+/**
+ * Pushes all local tags to the configured remote repository.
+ * Only pushes tags that don't exist on remote. Does NOT push commits.
+ * @param options - Git operation options
+ * @returns Promise that resolves when all tags are successfully pushed
+ * @throws {Error} If push fails (no remote, authentication, network, conflicts, etc.)
+ */
+export async function pushTags(options = {}) {
+    // Resolve working directory
+    const cwd = options.cwd || process.cwd();
+    try {
+        // Push all tags to the remote repository
+        // --tags: Push all tags (annotated and lightweight)
+        // This does NOT push commits, only tags
+        await execa("git", ["push", "--tags"], { cwd });
+    }
+    catch (error) {
+        // Wrap error with context
+        // Common failures: no remote, auth, network, conflicts
+        throw new Error(`Failed to push tags: ${error}`);
+    }
+}
+/**
+ * Generates a glob pattern for searching module-specific git tags (moduleName@*).
+ * @param moduleName - The name of the module
+ * @returns A glob pattern string matching all tags for the module
+ * @internal
+ */
+function getModuleTagPattern(moduleName) {
+    // Create glob pattern for module-specific tags
+    // Format: moduleName@* where * matches any version
+    return `${moduleName}@*`;
+}
+/**
+ * Parses a git tag name to extract module and version components.
+ *
+ * This internal utility function handles multiple tag naming conventions used in
+ * μVERSE and returns a structured object with extracted metadata. It supports:
+ * - **Module tags**: `moduleName@version` (monorepo convention)
+ * - **Version tags**: `v{version}` or `{version}` (single repo convention)
+ * - **Custom tags**: Returns empty object for unrecognized formats
+ *
+ * @param tagName - The full git tag name to parse.
+ *                  Can be any string, but structured formats are recognized.
+ *
+ * @returns Object with optional `module` and `version` fields:
+ *          - Both present: Module tag (e.g., `core@1.0.0`)
+ *          - Only version: General tag (e.g., `v1.0.0`)
+ *          - Empty object: Unrecognized format
+ * @internal
+ */
+function parseTagName(tagName) {
+    // Try to match module-specific tag pattern: moduleName@version
+    // Regex: ^(.+)@(.+)$
+    //   ^(.+)  - Start of string, capture group 1 (module name, greedy)
+    //   @      - Literal @ separator
+    //   (.+)$  - Capture group 2 (version, greedy), end of string
+    const match = tagName.match(/^(.+)@(.+)$/);
+    if (match) {
+        // Module tag matched - return both components
+        return {
+            module: match[1],
+            version: match[2],
+        };
+    }
+    // Try to match version-only tag pattern: v?MAJOR.MINOR.PATCH...
+    // Regex: ^v?(\d+\.\d+\.\d+.*)$
+    //   ^v?           - Start, optional 'v' prefix
+    //   (\d+\.\d+\.\d+  - Capture group: MAJOR.MINOR.PATCH (digits)
+    //   .*)$          - Any remaining characters (pre-release, metadata), end
+    const versionMatch = tagName.match(/^v?(\d+\.\d+\.\d+.*)$/);
+    if (versionMatch) {
+        // Version tag matched - return only version (no module)
+        return {
+            version: versionMatch[1],
+        };
+    }
+    // Unrecognized format - return empty object
+    return {};
+}
+/**
+ * Checks if the git working directory is clean (no uncommitted changes).
+ * Uses `git status --porcelain` to detect modified, staged, deleted, or untracked files.
+ * @param options - Git operation options
+ * @returns Promise resolving to true if clean, false if there are changes or on error
+ */
+export async function isWorkingDirectoryClean(options = {}) {
+    // Resolve working directory
+    const cwd = options.cwd || process.cwd();
+    try {
+        // Get machine-readable status output
+        // --porcelain: Stable, easy-to-parse format
+        const { stdout } = await execa("git", ["status", "--porcelain"], {
+            cwd,
+        });
+        // Empty output means clean working directory
+        // Any output indicates changes (modified, untracked, staged, etc.)
+        return stdout.trim() === "";
+    }
+    catch (error) {
+        // On error, assume directory is not clean (safe default)
+        // This could happen if not a git repo, or permissions issue
+        return false;
+    }
+}
+/**
+ * Retrieves the name of the currently checked out git branch.
+ *
+ * This function returns the active branch name, which is useful for:
+ * - Conditional logic based on branch (e.g., only release from 'main')
+ * - CI/CD branch-specific workflows
+ * - Logging and debugging
+ * - Branch validation before operations
+ *
+ * Returns empty string if in detached HEAD state.
+ * @param options - Git operation options
+ * @returns Promise resolving to the current branch name (empty string if detached HEAD)
+ * @throws {Error} If git command fails
+ */
+export async function getCurrentBranch(options = {}) {
+    // Resolve working directory
+    const cwd = options.cwd || process.cwd();
+    try {
+        // Get the current branch name
+        // --show-current: Returns active branch name or empty string if detached
+        const { stdout } = await execa("git", ["branch", "--show-current"], {
+            cwd,
+        });
+        // Return branch name (or empty string for detached HEAD)
+        return stdout.trim();
+    }
+    catch (error) {
+        // Wrap error with context
+        throw new Error(`Failed to get current branch: ${error}`);
+    }
+}
+/**
+ * Retrieves the abbreviated (short) SHA-1 hash of the current HEAD commit.
+ *
+ * This function returns a shortened version of the commit hash (typically 7 characters),
+ * which is:
+ * - Human-readable and easier to reference
+ * - Suitable for build metadata in semantic versions
+ * - Commonly used in CI/CD for build identification
+ * - Still unique enough for most repositories
+ *
+ * The short SHA is git's default abbreviated format and balances uniqueness with brevity.
+ *
+ * @param options - Git operation options, primarily for specifying working directory.
+ *
+ * @returns Promise resolving to the abbreviated commit SHA.
+ *          Typically 7 characters (e.g., 'abc1234').
+ *          Length may vary based on repository size to ensure uniqueness.
+ *
+ * @throws {Error} If git command fails:
+ *                 - Not in a git repository
+ *                 - No commits exist (empty repository)
+ *                 - Permissions issues
+ */
+export async function getCurrentCommitShortSha(options = {}) {
+    // Resolve working directory
+    const cwd = options.cwd || process.cwd();
+    try {
+        // Get abbreviated commit SHA
+        // rev-parse: Resolve git revision to commit hash
+        // --short: Return abbreviated version (typically 7 chars)
+        // HEAD: The current commit
+        const { stdout } = await execa("git", ["rev-parse", "--short", "HEAD"], {
+            cwd,
+        });
+        // Return the short SHA
+        return stdout.trim();
+    }
+    catch (error) {
+        // Wrap error with context
+        throw new Error(`Failed to get current commit SHA: ${error}`);
+    }
+}
+/**
+ * Stages all changed files in the working directory for the next commit.
+ *
+ * This function executes `git add .` which stages:
+ * - All modified tracked files
+ * - All new untracked files
+ * - All deleted files
+ *
+ * **Warning**: This stages **everything** in the working directory. Use with caution
+ * in interactive environments. For selective staging, use git commands directly.
+ *
+ * @param options - Git operation options, primarily for specifying working directory.
+ *
+ * @returns Promise that resolves when all files are successfully staged.
+ *
+ * @throws {Error} If git add command fails:
+ *                 - Not in a git repository
+ *                 - Permissions issues
+ *                 - Invalid .gitignore patterns
+ */
+export async function addChangedFiles(options = {}) {
+    // Resolve working directory
+    const cwd = options.cwd || process.cwd();
+    try {
+        // Stage all changes in the working directory
+        // '.': Current directory and all subdirectories
+        await execa("git", ["add", "."], { cwd });
+    }
+    catch (error) {
+        // Wrap error with context
+        throw new Error(`Failed to add changed files: ${error}`);
+    }
+}
+/**
+ * Creates a git commit with the specified message using currently staged changes.
+ * Files must be staged first (via `git add`). Follows Conventional Commits format.
+ * @param message - The commit message (e.g., 'feat: description', 'fix: description')
+ * @param options - Git operation options
+ * @returns Promise that resolves when commit is created
+ * @throws {Error} If commit fails (no staged changes, no git user, empty message, etc.)
+ */
+export async function commitChanges(message, options = {}) {
+    // Resolve working directory
+    const cwd = options.cwd || process.cwd();
+    try {
+        // Create commit with staged changes
+        // -m: Specify commit message inline
+        await execa("git", ["commit", "-m", message], { cwd });
+    }
+    catch (error) {
+        // Wrap error with context
+        throw new Error(`Failed to commit changes: ${error}`);
+    }
+}
+/**
+ * Pushes local commits to the remote repository.
+ *
+ * This function uploads all commits from the current branch that don't exist
+ * on the remote. It uses `git push` without arguments, which:
+ * - Pushes the current branch to its configured upstream
+ * - Only pushes commits (use `pushTags()` for tags)
+ * - Requires network access and authentication
+ *
+ * @param options - Git operation options, primarily for specifying working directory.
+ *
+ * @returns Promise that resolves when commits are successfully pushed.
+ *
+ * @throws {Error} If push fails:
+ *                 - No remote configured
+ *                 - No upstream branch set
+ *                 - Authentication failure
+ *                 - Network issues
+ *                 - Remote rejects (e.g., force push needed, protected branch)
+ */
+export async function pushCommits(options = {}) {
+    // Resolve working directory
+    const cwd = options.cwd || process.cwd();
+    try {
+        // Push commits to remote
+        // No arguments: Push current branch to configured upstream
+        await execa("git", ["push"], { cwd });
+    }
+    catch (error) {
+        // Wrap error with context
+        throw new Error(`Failed to push commits: ${error}`);
+    }
+}
+/**
+ * Checks if there are any changes in the working directory or staging area.
+ *
+ * This function is similar to `isWorkingDirectoryClean()` but returns the opposite
+ * boolean value. It's useful when you want to check if there's work to commit.
+ *
+ * Uses `git status --porcelain` to detect:
+ * - Modified tracked files
+ * - New untracked files
+ * - Deleted files
+ * - Staged changes
+ *
+ * @param options - Git operation options, primarily for specifying working directory.
+ *
+ * @returns Promise resolving to:
+ *          - `true`: There are changes (modified, staged, untracked files)
+ *          - `false`: Working directory is clean OR git command failed
+ *
+ * @throws {Error} If git status command fails.
+ *                 Unlike `isWorkingDirectoryClean()`, this function throws on errors.
+ */
+export async function hasChangesToCommit(options = {}) {
+    // Resolve working directory
+    const cwd = options.cwd || process.cwd();
+    try {
+        // Get machine-readable status output
+        // --porcelain: Stable, easy-to-parse format
+        const { stdout } = await execa("git", ["status", "--porcelain"], {
+            cwd,
+        });
+        // If output is not empty, there are changes
+        // Returns true if changes exist, false if clean
+        return stdout.trim().length > 0;
+    }
+    catch (error) {
+        // Throw on error (unlike isWorkingDirectoryClean which returns false)
+        throw new Error(`Failed to check git status: ${error}`);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+export * from './config/index.js';
+export { VerseRunner } from './services/verse-runner.js';
+export type { RunnerOptions, RunnerResult } from './services/verse-runner.js';
+export { VersionManager } from './services/version-manager.js';
+export { ModuleRegistry } from './services/module-registry.js';
+export { VersionBumper } from './services/version-bumper.js';
+export type { VersionBumperOptions } from './services/version-bumper.js';
+export { VersionApplier } from './services/version-applier.js';
+export type { VersionApplierOptions, ModuleChangeResult } from './services/version-applier.js';
+export { ChangelogGenerator } from './services/changelog-generator.js';
+export { GitOperations } from './services/git-operations.js';
+export type { GitOperationsOptions } from './services/git-operations.js';
+export { CommitAnalyzer } from './services/commit-analyzer.js';
+export { ConfigurationLoader } from './services/configuration-loader.js';
+export type { AdapterIdentifier, AdapterMetadata } from './services/adapter-identifier.js';
+export { AdapterIdentifierRegistry } from './services/adapter-identifier-registry.js';
+export type { ProjectInformation, Module } from './adapters/project-information.js';
+export { createModuleSystemFactory } from './factories/module-system-factory.js';
+export type { ModuleSystemFactory } from './services/module-system-factory.js';
+export * from './git/index.js';
+export * from './semver/index.js';
+export * from './utils/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,cAAc,mBAAmB,CAAC;AAGlC,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC9E,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC7D,YAAY,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACzE,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,YAAY,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAC/F,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC7D,YAAY,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACzE,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AACzE,YAAY,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAC3F,OAAO,EAAE,yBAAyB,EAAE,MAAM,2CAA2C,CAAC;AAGtF,YAAY,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,mCAAmC,CAAC;AAGpF,OAAO,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAC;AACjF,YAAY,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAG/E,cAAc,gBAAgB,CAAC;AAG/B,cAAc,mBAAmB,CAAC;AAGlC,cAAc,kBAAkB,CAAC"}

package/dist/index.js

@@ -0,0 +1,22 @@
+// Core μVERSE exports - business logic without GitHub Actions dependency
+// Configuration
+export * from './config/index.js';
+// Services
+export { VerseRunner } from './services/verse-runner.js';
+export { VersionManager } from './services/version-manager.js';
+export { ModuleRegistry } from './services/module-registry.js';
+export { VersionBumper } from './services/version-bumper.js';
+export { VersionApplier } from './services/version-applier.js';
+export { ChangelogGenerator } from './services/changelog-generator.js';
+export { GitOperations } from './services/git-operations.js';
+export { CommitAnalyzer } from './services/commit-analyzer.js';
+export { ConfigurationLoader } from './services/configuration-loader.js';
+export { AdapterIdentifierRegistry } from './services/adapter-identifier-registry.js';
+// Factories
+export { createModuleSystemFactory } from './factories/module-system-factory.js';
+// Git utilities
+export * from './git/index.js';
+// Semver utilities
+export * from './semver/index.js';
+// Utilities
+export * from './utils/index.js';