@versu/core 0.4.0

package/dist/config/index.d.ts

@@ -0,0 +1,122 @@
+import { z } from "zod";
+import { BumpType } from "../semver/index.js";
+import { Commit } from "conventional-commits-parser";
+/**
+ * Zod schema for DependencyRules configuration.
+ * Validates that dependency cascade rules use valid bump types.
+ */
+declare const dependencyRulesSchema: z.ZodObject<{
+    onMajorOfDependency: z.ZodEnum<{
+        major: "major";
+        minor: "minor";
+        patch: "patch";
+        none: "none";
+    }>;
+    onMinorOfDependency: z.ZodEnum<{
+        major: "major";
+        minor: "minor";
+        patch: "patch";
+        none: "none";
+    }>;
+    onPatchOfDependency: z.ZodEnum<{
+        major: "major";
+        minor: "minor";
+        patch: "patch";
+        none: "none";
+    }>;
+}, z.core.$strip>;
+/**
+ * Zod schema for NodeJSConfig configuration.
+ * Validates Node.js-specific settings.
+ */
+declare const nodeJSConfigSchema: z.ZodObject<{
+    versionSource: z.ZodArray<z.ZodLiteral<"package.json">>;
+    updatePackageLock: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * Zod schema for the main Config object.
+ * This schema is used by ConfigurationValidator to ensure type-safe
+ * configuration with detailed error messages for invalid configurations.
+ */
+export declare const configSchema: z.ZodObject<{
+    defaultBump: z.ZodEnum<{
+        major: "major";
+        minor: "minor";
+        patch: "patch";
+        none: "none";
+    }>;
+    commitTypes: z.ZodRecord<z.ZodString, z.ZodEnum<{
+        major: "major";
+        minor: "minor";
+        patch: "patch";
+        none: "none";
+        ignore: "ignore";
+    }>>;
+    dependencyRules: z.ZodObject<{
+        onMajorOfDependency: z.ZodEnum<{
+            major: "major";
+            minor: "minor";
+            patch: "patch";
+            none: "none";
+        }>;
+        onMinorOfDependency: z.ZodEnum<{
+            major: "major";
+            minor: "minor";
+            patch: "patch";
+            none: "none";
+        }>;
+        onPatchOfDependency: z.ZodEnum<{
+            major: "major";
+            minor: "minor";
+            patch: "patch";
+            none: "none";
+        }>;
+    }, z.core.$strip>;
+    nodejs: z.ZodOptional<z.ZodObject<{
+        versionSource: z.ZodArray<z.ZodLiteral<"package.json">>;
+        updatePackageLock: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Configuration for VERSU version bumping behavior.
+ * Controls commit type handling, dependency cascade rules, and adapter-specific settings.
+ */
+export type Config = z.infer<typeof configSchema>;
+/**
+ * Rules for propagating version changes through dependency relationships.
+ * Defines how a module should be bumped when its dependencies change.
+ */
+export type DependencyRules = z.infer<typeof dependencyRulesSchema>;
+/**
+ * Configuration for Node.js/npm projects.
+ */
+export type NodeJSConfig = z.infer<typeof nodeJSConfigSchema>;
+/**
+ * Default VERSU configuration following Conventional Commits specification.
+ * Maps common commit types to semantic version bumps and defines dependency cascade rules.
+ */
+export declare const DEFAULT_CONFIG: Config;
+/**
+ * Determines the bump type for a commit based on its type and breaking change flag.
+ * @param commit - The commit to evaluate
+ * @param config - Configuration containing commit type mappings
+ * @returns The bump type to apply ('major', 'minor', 'patch', or 'none')
+ */
+export declare function getBumpTypeForCommit(commit: Commit, config: Config): BumpType;
+/**
+ * Determines how a module should be bumped when one of its dependencies changes.
+ * Uses dependency cascade rules from configuration to propagate version changes.
+ * @param dependencyBumpType - The bump type applied to the dependency
+ * @param config - Configuration containing dependency cascade rules
+ * @returns The bump type to apply to the dependent module
+ */
+export declare function getDependencyBumpType(dependencyBumpType: BumpType, config: Config): BumpType;
+/**
+ * Retrieves adapter-specific configuration from the main config object.
+ * @param config - The main configuration object
+ * @param adapterName - The name of the adapter configuration to retrieve
+ * @returns The adapter-specific configuration, or undefined if not present
+ */
+export declare function getAdapterConfig<T extends keyof Config>(config: Config, adapterName: T): Config[T];
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAqBrD;;;GAGG;AACH,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;iBAIzB,CAAC;AAEH;;;GAGG;AACH,QAAA,MAAM,kBAAkB;;;iBAGtB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKvB,CAAC;AAEH;;;GAGG;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAElD;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,MAmB5B,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,QAAQ,CAe7E;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,kBAAkB,EAAE,QAAQ,EAC5B,MAAM,EAAE,MAAM,GACb,QAAQ,CAaV;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,MAAM,MAAM,EACrD,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,CAAC,GACb,MAAM,CAAC,CAAC,CAAC,CAEX"}

package/dist/config/index.js

@@ -0,0 +1,117 @@
+import { z } from "zod";
+import { isBreakingCommit } from "../git/index.js";
+/**
+ * Zod schema for BumpType values.
+ * Used for validation in configuration files.
+ */
+const bumpTypeSchema = z.enum(["major", "minor", "patch", "none"]);
+/**
+ * Zod schema for BumpType or 'ignore' values.
+ * Used for commit type mappings where 'ignore' is allowed.
+ */
+const bumpTypeOrIgnoreSchema = z.enum([
+    "major",
+    "minor",
+    "patch",
+    "none",
+    "ignore",
+]);
+/**
+ * Zod schema for DependencyRules configuration.
+ * Validates that dependency cascade rules use valid bump types.
+ */
+const dependencyRulesSchema = z.object({
+    onMajorOfDependency: bumpTypeSchema,
+    onMinorOfDependency: bumpTypeSchema,
+    onPatchOfDependency: bumpTypeSchema,
+});
+/**
+ * Zod schema for NodeJSConfig configuration.
+ * Validates Node.js-specific settings.
+ */
+const nodeJSConfigSchema = z.object({
+    versionSource: z.array(z.literal("package.json")),
+    updatePackageLock: z.boolean(),
+});
+/**
+ * Zod schema for the main Config object.
+ * This schema is used by ConfigurationValidator to ensure type-safe
+ * configuration with detailed error messages for invalid configurations.
+ */
+export const configSchema = z.object({
+    defaultBump: bumpTypeSchema,
+    commitTypes: z.record(z.string(), bumpTypeOrIgnoreSchema),
+    dependencyRules: dependencyRulesSchema,
+    nodejs: nodeJSConfigSchema.optional(),
+});
+/**
+ * Default VERSU configuration following Conventional Commits specification.
+ * Maps common commit types to semantic version bumps and defines dependency cascade rules.
+ */
+export const DEFAULT_CONFIG = {
+    defaultBump: "patch",
+    commitTypes: {
+        feat: "minor",
+        fix: "patch",
+        perf: "patch",
+        refactor: "patch",
+        docs: "ignore",
+        test: "ignore",
+        chore: "ignore",
+        style: "ignore",
+        ci: "ignore",
+        build: "ignore",
+    },
+    dependencyRules: {
+        onMajorOfDependency: "major",
+        onMinorOfDependency: "minor",
+        onPatchOfDependency: "patch",
+    },
+};
+/**
+ * Determines the bump type for a commit based on its type and breaking change flag.
+ * @param commit - The commit to evaluate
+ * @param config - Configuration containing commit type mappings
+ * @returns The bump type to apply ('major', 'minor', 'patch', or 'none')
+ */
+export function getBumpTypeForCommit(commit, config) {
+    const isBreaking = isBreakingCommit(commit);
+    if (isBreaking) {
+        return "major";
+    }
+    const commitType = commit.type || "unknown";
+    const configuredBump = config.commitTypes[commitType];
+    if (configuredBump === "ignore") {
+        return "none";
+    }
+    return configuredBump || config.defaultBump;
+}
+/**
+ * Determines how a module should be bumped when one of its dependencies changes.
+ * Uses dependency cascade rules from configuration to propagate version changes.
+ * @param dependencyBumpType - The bump type applied to the dependency
+ * @param config - Configuration containing dependency cascade rules
+ * @returns The bump type to apply to the dependent module
+ */
+export function getDependencyBumpType(dependencyBumpType, config) {
+    const rules = config.dependencyRules;
+    switch (dependencyBumpType) {
+        case "major":
+            return rules.onMajorOfDependency;
+        case "minor":
+            return rules.onMinorOfDependency;
+        case "patch":
+            return rules.onPatchOfDependency;
+        default:
+            return "none";
+    }
+}
+/**
+ * Retrieves adapter-specific configuration from the main config object.
+ * @param config - The main configuration object
+ * @param adapterName - The name of the adapter configuration to retrieve
+ * @returns The adapter-specific configuration, or undefined if not present
+ */
+export function getAdapterConfig(config, adapterName) {
+    return config[adapterName];
+}

package/dist/factories/adapter-identifier-registry.d.ts

@@ -0,0 +1,12 @@
+import { AdapterIdentifierRegistry } from "../services/adapter-identifier-registry.js";
+/**
+ * Creates and configures the global adapter identifier registry.
+ *
+ * @returns Configured {@link AdapterIdentifierRegistry} with all available adapters
+ *
+ * @remarks
+ * Central point for registering all supported project adapters.
+ * To add a new adapter, implement {@link AdapterIdentifier} and add it to the array.
+ */
+export declare function createAdapterIdentifierRegistry(): AdapterIdentifierRegistry;
+//# sourceMappingURL=adapter-identifier-registry.d.ts.map

package/dist/factories/adapter-identifier-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-identifier-registry.d.ts","sourceRoot":"","sources":["../../src/factories/adapter-identifier-registry.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,yBAAyB,EAAE,MAAM,4CAA4C,CAAC;AAEvF;;;;;;;;GAQG;AACH,wBAAgB,+BAA+B,IAAI,yBAAyB,CAc3E"}

package/dist/factories/adapter-identifier-registry.js

@@ -0,0 +1,24 @@
+import { GradleAdapterIdentifier } from "../adapters/gradle/services/gradle-adapter-identifier.js";
+import { AdapterIdentifierRegistry } from "../services/adapter-identifier-registry.js";
+/**
+ * Creates and configures the global adapter identifier registry.
+ *
+ * @returns Configured {@link AdapterIdentifierRegistry} with all available adapters
+ *
+ * @remarks
+ * Central point for registering all supported project adapters.
+ * To add a new adapter, implement {@link AdapterIdentifier} and add it to the array.
+ */
+export function createAdapterIdentifierRegistry() {
+    // Array of all registered adapter identifiers
+    // Order matters: first matching adapter is selected during auto-detection
+    const identifiers = [
+        new GradleAdapterIdentifier(),
+        // Add future adapter identifiers here as they are implemented:
+        // new MavenAdapterIdentifier(),
+        // new NodeJSAdapterIdentifier(),
+        // new PythonAdapterIdentifier(),
+    ];
+    // Create and return the registry with all registered identifiers
+    return new AdapterIdentifierRegistry(identifiers);
+}

package/dist/factories/module-system-factory.d.ts

@@ -0,0 +1,10 @@
+import { ModuleSystemFactory } from "../services/module-system-factory.js";
+/**
+ * Creates the appropriate module system factory for a given adapter.
+ * @param adapterName - The identifier of the build system adapter (e.g., 'gradle', 'maven', 'npm')
+ * @param repoRoot - The absolute path to the repository root directory
+ * @returns A ModuleSystemFactory instance configured for the specified adapter
+ * @throws {Error} If the adapter name is not recognized or supported
+ */
+export declare function createModuleSystemFactory(adapterName: string, repoRoot: string): ModuleSystemFactory;
+//# sourceMappingURL=module-system-factory.d.ts.map

package/dist/factories/module-system-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-system-factory.d.ts","sourceRoot":"","sources":["../../src/factories/module-system-factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAI3E;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,GACf,mBAAmB,CASrB"}

package/dist/factories/module-system-factory.js

@@ -0,0 +1,18 @@
+import { GradleModuleSystemFactory } from "../adapters/gradle/services/gradle-module-system-factory.js";
+import { GRADLE_ID } from "../adapters/gradle/constants.js";
+/**
+ * Creates the appropriate module system factory for a given adapter.
+ * @param adapterName - The identifier of the build system adapter (e.g., 'gradle', 'maven', 'npm')
+ * @param repoRoot - The absolute path to the repository root directory
+ * @returns A ModuleSystemFactory instance configured for the specified adapter
+ * @throws {Error} If the adapter name is not recognized or supported
+ */
+export function createModuleSystemFactory(adapterName, repoRoot) {
+    // Normalize adapter name to lowercase for case-insensitive matching
+    switch (adapterName.toLowerCase()) {
+        case GRADLE_ID:
+            return new GradleModuleSystemFactory(repoRoot);
+        default:
+            throw new Error(`Unsupported adapter: ${adapterName}`);
+    }
+}

package/dist/git/index.d.ts

@@ -0,0 +1,355 @@
+/**
+ * Git operations module for VERSU version management.
+ * Provides interfaces for commit analysis, tagging, and conventional commit parsing.
+ * Supports monorepo and multi-module projects with module-specific tag management.
+ */
+import { Commit } from "conventional-commits-parser";
+import { Module } from "../index.js";
+/**
+ * Represents a parsed git tag with extracted module and version metadata.
+ * Supports module tags (moduleName@version) and general tags (v{version}).
+ */
+export type GitTag = {
+    /** The full tag name as it appears in git (e.g., 'core@1.0.0', 'v2.0.0') */
+    readonly name: string;
+    /** The full SHA-1 commit hash that this tag points to */
+    readonly hash: string;
+    /**
+     * The module name extracted from the tag (e.g., 'core' from 'core@1.0.0').
+     * Undefined for general tags or unparseable tag names.
+     */
+    readonly module?: string;
+    /**
+     * The semantic version extracted from the tag (e.g., '1.0.0' from 'core@1.0.0' or 'v1.0.0').
+     * Undefined for unparseable tag names.
+     */
+    readonly version?: string;
+};
+/**
+ * Configuration options for executing git operations.
+ * @property cwd - Working directory for git commands (defaults to process.cwd())
+ */
+export type GitOptions = {
+    /**
+     * The working directory in which to execute git commands.
+     * Must be inside a git repository or a subdirectory of one.
+     * Defaults to `process.cwd()` if not specified.
+     */
+    readonly cwd?: string;
+};
+/**
+ * Represents a parsed git commit following the Conventional Commits specification.
+ * Extracts type, scope, breaking changes, and descriptive content for version bumping.
+ */
+export type CommitInfo = {
+    /** The full SHA-1 commit hash (40 hexadecimal characters) */
+    readonly hash: string;
+    /**
+     * The commit type indicating the nature of the change.
+     * Common values: 'feat', 'fix', 'docs', 'chore', 'refactor', 'test', 'unknown'.
+     * Used to determine version bump strategy.
+     */
+    readonly type: string;
+    /**
+     * Optional scope providing additional context about what was changed.
+     * Examples: 'api', 'core', 'ui', 'auth'.
+     * Not used for version bumping but useful for changelog organization.
+     */
+    readonly scope?: string;
+    /**
+     * The commit subject line without type and scope prefix.
+     * Should be a concise description of the change.
+     */
+    readonly subject: string;
+    /**
+     * The full commit body text, if present.
+     * May contain detailed explanations, breaking change descriptions, and footer metadata.
+     */
+    readonly body?: string;
+    /**
+     * Whether this commit introduces breaking changes.
+     * Detected from 'BREAKING CHANGE:' footer or '!' suffix in commit message.
+     * When true, always triggers a major version bump.
+     */
+    readonly breaking: boolean;
+    /**
+     * Optional module name if the commit is specific to a module in a monorepo.
+     * Not currently extracted by the parser but reserved for future use.
+     */
+    readonly module?: string;
+    readonly parsed?: Commit;
+};
+/**
+ * Retrieves all commits for a module since its last release tag.
+ * Handles monorepo and single-repo scenarios with path filtering.
+ * @param projectInfo - Module information including path and type
+ * @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 declare function getCommitsSinceLastTag(projectInfo: Module, options?: GitOptions, excludePaths?: string[]): Promise<{
+    commits: Commit[];
+    lastTag: string | null;
+}>;
+/**
+ * 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 declare function getCommitsInRange(range: string, pathFilter?: string, options?: GitOptions, excludePaths?: string[]): Promise<Commit[]>;
+export declare function isBreakingCommit(commit: Commit): boolean;
+/**
+ * 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 projectInfo - Module information for tag pattern construction
+ * @param options - Git operation options
+ * @returns Most recent tag name or null if no tags exist
+ */
+export declare function getLastTagForModule(projectInfo: Module, options?: GitOptions): Promise<string | 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 declare function getAllTags(options?: GitOptions): Promise<GitTag[]>;
+/**
+ * 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 declare function createTag(tagName: string, message: string, options?: GitOptions): Promise<void>;
+/**
+ * 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 declare function pushTags(options?: GitOptions): Promise<void>;
+/**
+ * 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 declare function isWorkingDirectoryClean(options?: GitOptions): Promise<boolean>;
+/**
+ * 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 declare function getCurrentBranch(options?: GitOptions): Promise<string>;
+/**
+ * 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 declare function getCurrentCommitShortSha(options?: GitOptions): Promise<string>;
+/**
+ * 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 declare function addChangedFiles(options?: GitOptions): Promise<void>;
+/**
+ * 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 declare function commitChanges(message: string, options?: GitOptions): Promise<void>;
+/**
+ * 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 declare function pushCommits(options?: GitOptions): Promise<void>;
+/**
+ * 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 declare function hasChangesToCommit(options?: GitOptions): Promise<boolean>;
+export declare function getCurrentRepoUrl(options?: GitOptions): Promise<string>;
+/**
+ * Parses a git repository URL (SSH or HTTP/HTTPS) and extracts its components.
+ *
+ * Supports multiple URL formats:
+ * - SSH: `git@github.com:owner/repo.git`
+ * - HTTPS: `https://github.com/owner/repo.git`
+ * - HTTP: `http://github.com/owner/repo.git`
+ *
+ * @param repoUrl - The repository URL to parse
+ * @returns Object containing host, owner, and repo name
+ * @throws {Error} If URL format is invalid or cannot be parsed
+ * @internal
+ */
+export declare function parseRepoUrl(repoUrl: string): {
+    host: string;
+    owner: string;
+    repo: string;
+};
+/**
+ * Retrieves the current repository URL and converts it to HTTPS format.
+ *
+ * This function is useful for:
+ * - Generating consistent HTTPS URLs for documentation
+ * - Creating web links to the repository
+ * - CI/CD systems that prefer HTTPS over SSH
+ *
+ * Converts SSH URLs (git@github.com:owner/repo.git) to HTTPS format
+ * (https://github.com/owner/repo.git).
+ *
+ * @param options - Git operation options, primarily for specifying working directory.
+ *
+ * @returns Promise resolving to the repository URL in HTTPS format.
+ *
+ * @throws {Error} If:
+ *                 - Unable to get remote URL
+ *                 - URL format is invalid
+ *                 - Not in a git repository
+ */
+export declare function getRepoUrlAsHttps(options?: GitOptions): Promise<string>;
+/**
+ * Extracts the hostname from the current repository's remote URL.
+ *
+ * Returns the hosting service domain (e.g., 'github.com', 'gitlab.com',
+ * 'bitbucket.org', or custom Git server hostname).
+ *
+ * Supports both SSH and HTTP/HTTPS URL formats.
+ *
+ * @param options - Git operation options, primarily for specifying working directory.
+ *
+ * @returns Promise resolving to the repository host (e.g., 'github.com').
+ *
+ * @throws {Error} If:
+ *                 - Unable to get remote URL
+ *                 - URL format is invalid
+ *                 - Not in a git repository
+ */
+export declare function getRepoHost(options?: GitOptions): Promise<string>;
+/**
+ * Extracts the repository owner/organization name from the current repository's remote URL.
+ *
+ * Returns the account or organization that owns the repository.
+ * For example:
+ * - `git@github.com:microsoft/vscode.git` → 'microsoft'
+ * - `https://github.com/facebook/react.git` → 'facebook'
+ *
+ * Supports both SSH and HTTP/HTTPS URL formats.
+ *
+ * @param options - Git operation options, primarily for specifying working directory.
+ *
+ * @returns Promise resolving to the repository owner name.
+ *
+ * @throws {Error} If:
+ *                 - Unable to get remote URL
+ *                 - URL format is invalid
+ *                 - Not in a git repository
+ */
+export declare function getRepoOwner(options?: GitOptions): Promise<string>;
+/**
+ * Extracts the repository name from the current repository's remote URL.
+ *
+ * Returns the name of the repository without the owner prefix or .git suffix.
+ * For example:
+ * - `git@github.com:microsoft/vscode.git` → 'vscode'
+ * - `https://github.com/facebook/react.git` → 'react'
+ *
+ * Supports both SSH and HTTP/HTTPS URL formats.
+ *
+ * @param options - Git operation options, primarily for specifying working directory.
+ *
+ * @returns Promise resolving to the repository name.
+ *
+ * @throws {Error} If:
+ *                 - Unable to get remote URL
+ *                 - URL format is invalid
+ *                 - Not in a git repository
+ */
+export declare function getRepoName(options?: GitOptions): Promise<string>;
+//# sourceMappingURL=index.d.ts.map