@glpkg/cli 0.2.0

package/dist/commands/publish.js

@@ -0,0 +1,666 @@
+"use strict";
+/**
+ * Publish Command - Publish packages to GitLab
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publishCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const child_process_1 = require("child_process");
+const core_1 = require("@glpkg/core");
+const adapters_npm_1 = require("@glpkg/adapters.npm");
+const adapters_generic_1 = require("@glpkg/adapters.generic");
+const adapters_pypi_1 = require("@glpkg/adapters.pypi");
+const adapters_go_1 = require("@glpkg/adapters.go");
+const adapters_nuget_1 = require("@glpkg/adapters.nuget");
+const fallback_1 = require("@glpkg/fallback");
+exports.publishCommand = new commander_1.Command('publish')
+    .alias('pub')
+    .argument('[type]', 'Publish type: latest, dev, beta', 'latest')
+    .description('Publish package to GitLab registry')
+    .option('--bump <type>', 'Version bump: patch, minor, major')
+    .option('--dry-run', 'Run without publishing')
+    .option('--token <token>', 'Override GitLab token')
+    .option('--no-build', 'Skip prepublishOnly script')
+    .option('--git-tag <bool>', 'Create git tag (default: true)', 'true')
+    .option('--push <bool>', 'Push to remote (default: true)', 'true')
+    .option('--force', 'Force publish')
+    .option('--generic', 'Publish as generic package')
+    .option('--pypi', 'Publish as PyPI package')
+    .option('--go', 'Publish as Go module')
+    .option('--nuget', 'Publish as NuGet package')
+    .option('--manifest <file>', 'Manifest file (generic only)')
+    .action(async (type, options) => {
+    try {
+        if (options.generic) {
+            await publishGeneric(options);
+        }
+        else if (options.pypi) {
+            await publishPyPI(type, options);
+        }
+        else if (options.go) {
+            await publishGo(type, options);
+        }
+        else if (options.nuget) {
+            await publishNuGet(type, options);
+        }
+        else {
+            await publishNpm(type, options);
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('✗'), 'Publish failed:', error.message);
+        process.exit(1);
+    }
+});
+/**
+ * Publish npm package
+ */
+async function publishNpm(type, options) {
+    console.log(chalk_1.default.blue.bold('glpkg publish'), chalk_1.default.gray('(npm)'));
+    console.log();
+    const tokenManager = (0, core_1.createTokenManager)();
+    const configManager = (0, core_1.createConfigManager)();
+    const token = tokenManager.resolveToken(options.token);
+    const pkgManager = (0, adapters_npm_1.createPackageJsonManager)();
+    const npmrcManager = (0, adapters_npm_1.createNpmrcManager)();
+    // Check git status
+    if (!options.dryRun) {
+        checkGitClean(options.force);
+    }
+    // Detect project info
+    const spinner = (0, ora_1.default)('Detecting project info...').start();
+    let projectInfo;
+    try {
+        const glabOutput = (0, child_process_1.execSync)('glab api projects/:id -X GET', { encoding: 'utf-8' });
+        const project = JSON.parse(glabOutput);
+        const client = (0, core_1.createClient)({ token });
+        const groupInfo = await client.getGroup(project.namespace.path);
+        projectInfo = {
+            projectId: project.id,
+            groupId: groupInfo.id,
+            namespace: project.namespace.path,
+            pathWithNamespace: project.path_with_namespace,
+        };
+        spinner.succeed(`Project: ${projectInfo.pathWithNamespace}`);
+    }
+    catch (error) {
+        spinner.fail('Failed to detect project');
+        console.error(chalk_1.default.yellow('→'), 'Run "glab auth login" to authenticate');
+        throw error;
+    }
+    // Setup .npmrc
+    const registryUrl = `https://gitlab.com/api/v4/projects/${projectInfo.projectId}/packages/npm/`;
+    const scope = pkgManager.getScope();
+    npmrcManager.backup();
+    try {
+        if (scope) {
+            npmrcManager.addScopeRegistry(scope, registryUrl);
+        }
+        npmrcManager.addAuthToken(registryUrl);
+        // Handle version bump
+        if (options.bump || type === 'dev') {
+            await bumpVersion(pkgManager, type, options.bump);
+        }
+        const version = pkgManager.getVersion();
+        const name = pkgManager.getName();
+        // Publish
+        const publishSpinner = (0, ora_1.default)(`Publishing ${name}@${version}...`).start();
+        if (options.dryRun) {
+            (0, child_process_1.execSync)('npm publish --dry-run', {
+                stdio: 'inherit',
+                env: tokenManager.getEnvWithToken(token),
+            });
+            publishSpinner.succeed('Dry-run complete');
+        }
+        else {
+            const tag = type === 'dev' ? 'dev' : type === 'beta' ? 'beta' : 'latest';
+            (0, child_process_1.execSync)(`npm publish --tag ${tag} --registry=${registryUrl}`, {
+                stdio: 'inherit',
+                env: tokenManager.getEnvWithToken(token),
+            });
+            publishSpinner.succeed(`Published ${name}@${version}`);
+            // Save to local cache for immediate install availability
+            try {
+                const packOutput = (0, child_process_1.execSync)('npm pack --json', { encoding: 'utf-8' });
+                const packResult = JSON.parse(packOutput);
+                const tarballName = Array.isArray(packResult) ? packResult[0].filename : packResult.filename;
+                if (tarballName) {
+                    const localCache = new fallback_1.LocalPackageCache();
+                    const tarballPath = require('path').join(process.cwd(), tarballName);
+                    await localCache.save(name, version, tarballPath);
+                    // Clean up the tarball file
+                    require('fs').unlinkSync(tarballPath);
+                    console.log(chalk_1.default.gray('○'), 'Saved to local cache');
+                }
+            }
+            catch {
+                // Cache save failure is not critical, continue
+            }
+            // Save package metadata
+            configManager.savePackageInfo({
+                packageName: name,
+                group: projectInfo.namespace,
+                groupId: projectInfo.groupId,
+                projectId: projectInfo.projectId,
+                projectPath: projectInfo.pathWithNamespace,
+                registryType: 'group',
+                registryUrl: `https://gitlab.com/api/v4/groups/${projectInfo.groupId}/-/packages/npm/`,
+                gitlabHost: 'gitlab.com',
+                lastUpdated: new Date().toISOString(),
+                source: 'published',
+            });
+            // Git operations
+            if (options.gitTag !== 'false' && type !== 'dev') {
+                createGitTag(version);
+            }
+            if (options.push !== 'false') {
+                pushToRemote(options.gitTag !== 'false' && type !== 'dev');
+            }
+        }
+        console.log();
+        console.log(chalk_1.default.green('✓'), 'Publish complete!');
+        console.log(chalk_1.default.gray('Package URL:'), `https://gitlab.com/${projectInfo.pathWithNamespace}/-/packages`);
+    }
+    finally {
+        npmrcManager.restore();
+    }
+}
+/**
+ * Publish generic package
+ */
+async function publishGeneric(options) {
+    console.log(chalk_1.default.blue.bold('glpkg publish'), chalk_1.default.gray('(generic)'));
+    console.log();
+    const tokenManager = (0, core_1.createTokenManager)();
+    const token = tokenManager.resolveToken(options.token);
+    const manifestReader = (0, adapters_generic_1.createManifestReader)();
+    const tarballCreator = (0, adapters_generic_1.createTarballCreator)();
+    const uploader = (0, adapters_generic_1.createUploader)('gitlab.com', token);
+    // Read manifest
+    const manifest = manifestReader.read(options.manifest);
+    console.log(chalk_1.default.gray('○'), `Package: ${manifest.name}@${manifest.version}`);
+    // Detect project
+    const spinner = (0, ora_1.default)('Detecting project...').start();
+    let projectId;
+    try {
+        const glabOutput = (0, child_process_1.execSync)('glab api projects/:id -X GET', { encoding: 'utf-8' });
+        const project = JSON.parse(glabOutput);
+        projectId = project.id;
+        spinner.succeed(`Project ID: ${projectId}`);
+    }
+    catch (error) {
+        spinner.fail('Failed to detect project');
+        throw error;
+    }
+    // Create tarball
+    const tarballSpinner = (0, ora_1.default)('Creating tarball...').start();
+    const tarballResult = tarballCreator.create(manifest);
+    tarballSpinner.succeed(`Created: ${manifestReader.getOutputName()}`);
+    // Upload
+    if (options.dryRun) {
+        console.log(chalk_1.default.yellow('→'), 'Dry-run: skipping upload');
+    }
+    else {
+        const uploadSpinner = (0, ora_1.default)('Uploading...').start();
+        const result = await uploader.upload({
+            projectId,
+            gitlabHost: 'gitlab.com',
+            token,
+            packageName: manifest.name,
+            packageVersion: manifest.version,
+            filename: manifestReader.getOutputName(),
+            filePath: tarballResult.tarballPath,
+        });
+        if (result.success) {
+            uploadSpinner.succeed('Upload complete');
+            // Save to local cache for immediate install availability
+            try {
+                const localCache = new fallback_1.LocalPackageCache();
+                await localCache.save(manifest.name, manifest.version, tarballResult.tarballPath);
+                console.log(chalk_1.default.gray('○'), 'Saved to local cache');
+            }
+            catch {
+                // Cache save failure is not critical
+            }
+        }
+        else {
+            uploadSpinner.fail(result.error || 'Upload failed');
+            throw new Error(result.error);
+        }
+    }
+    console.log();
+    console.log(chalk_1.default.green('✓'), 'Publish complete!');
+}
+/**
+ * Publish PyPI package
+ */
+async function publishPyPI(type, options) {
+    console.log(chalk_1.default.blue.bold('glpkg publish'), chalk_1.default.gray('(pypi)'));
+    console.log();
+    const tokenManager = (0, core_1.createTokenManager)();
+    const token = tokenManager.resolveToken(options.token);
+    const pyprojectManager = (0, adapters_pypi_1.createPyProjectManager)();
+    const executor = (0, adapters_pypi_1.createCommandExecutor)();
+    // Check tools availability
+    if (!executor.hasBuild()) {
+        console.error(chalk_1.default.red('✗'), 'python build not found. Install with: pip install build');
+        process.exit(1);
+    }
+    if (!executor.hasTwine()) {
+        console.error(chalk_1.default.red('✗'), 'twine not found. Install with: pip install twine');
+        process.exit(1);
+    }
+    // Check pyproject.toml exists
+    if (!pyprojectManager.exists()) {
+        console.error(chalk_1.default.red('✗'), 'pyproject.toml not found');
+        process.exit(1);
+    }
+    // Check git status
+    if (!options.dryRun) {
+        checkGitClean(options.force);
+    }
+    // Detect project
+    const spinner = (0, ora_1.default)('Detecting project...').start();
+    let projectId;
+    let pathWithNamespace;
+    try {
+        const glabOutput = (0, child_process_1.execSync)('glab api projects/:id -X GET', { encoding: 'utf-8' });
+        const project = JSON.parse(glabOutput);
+        projectId = project.id;
+        pathWithNamespace = project.path_with_namespace;
+        spinner.succeed(`Project ID: ${projectId}`);
+    }
+    catch (error) {
+        spinner.fail('Failed to detect project');
+        throw error;
+    }
+    // Handle version bump
+    if (options.bump) {
+        const currentVersion = pyprojectManager.getVersion();
+        const newVersion = (0, core_1.incrementVersion)(currentVersion.replace(/-.*$/, ''), options.bump);
+        pyprojectManager.setVersion(newVersion);
+        console.log(chalk_1.default.gray('○'), `Version: ${currentVersion} → ${newVersion}`);
+    }
+    const name = pyprojectManager.getName();
+    const version = pyprojectManager.getVersion();
+    console.log(chalk_1.default.gray('○'), `Package: ${name}@${version}`);
+    // Build
+    if (!options.noBuild) {
+        const buildSpinner = (0, ora_1.default)('Building package...').start();
+        try {
+            executor.build();
+            buildSpinner.succeed('Build complete');
+        }
+        catch (error) {
+            buildSpinner.fail('Build failed');
+            throw error;
+        }
+    }
+    // Upload with twine
+    const uploadUrl = (0, adapters_pypi_1.buildProjectUploadUrl)(projectId);
+    if (options.dryRun) {
+        console.log(chalk_1.default.yellow('→'), 'Dry-run: skipping upload');
+        console.log(chalk_1.default.gray('  Would upload to:'), uploadUrl);
+    }
+    else {
+        const uploadSpinner = (0, ora_1.default)('Uploading to GitLab PyPI registry...').start();
+        try {
+            executor.upload('dist/*', uploadUrl, {
+                username: '__token__',
+                password: token,
+            });
+            uploadSpinner.succeed(`Published ${name}@${version}`);
+            // Git operations
+            if (options.gitTag !== 'false' && type !== 'dev') {
+                createGitTag(version, 'pyproject.toml');
+            }
+            if (options.push !== 'false') {
+                pushToRemote(options.gitTag !== 'false' && type !== 'dev');
+            }
+        }
+        catch (error) {
+            uploadSpinner.fail('Upload failed');
+            throw error;
+        }
+    }
+    console.log();
+    console.log(chalk_1.default.green('✓'), 'Publish complete!');
+    console.log(chalk_1.default.gray('Package URL:'), `https://gitlab.com/${pathWithNamespace}/-/packages`);
+}
+/**
+ * Publish Go module
+ * Go modules are published via git tags - GitLab automatically serves them via Go proxy
+ */
+async function publishGo(type, options) {
+    console.log(chalk_1.default.blue.bold('glpkg publish'), chalk_1.default.gray('(go)'));
+    console.log();
+    const goModManager = (0, adapters_go_1.createGoModManager)();
+    const executor = (0, adapters_go_1.createCommandExecutor)();
+    // Check Go availability
+    if (!executor.hasGo()) {
+        console.error(chalk_1.default.red('✗'), 'Go not found. Please install Go.');
+        process.exit(1);
+    }
+    // Check go.mod exists
+    if (!goModManager.exists()) {
+        console.error(chalk_1.default.red('✗'), 'go.mod not found');
+        process.exit(1);
+    }
+    // Check git status
+    if (!options.dryRun) {
+        checkGitClean(options.force);
+    }
+    // Read module info
+    const goMod = goModManager.read();
+    const modulePath = goMod.module;
+    console.log(chalk_1.default.gray('○'), `Module: ${modulePath}`);
+    // Detect project
+    const spinner = (0, ora_1.default)('Detecting project...').start();
+    let pathWithNamespace;
+    try {
+        const glabOutput = (0, child_process_1.execSync)('glab api projects/:id -X GET', { encoding: 'utf-8' });
+        const project = JSON.parse(glabOutput);
+        pathWithNamespace = project.path_with_namespace;
+        spinner.succeed(`Project: ${pathWithNamespace}`);
+    }
+    catch (error) {
+        spinner.fail('Failed to detect project');
+        throw error;
+    }
+    // Determine version
+    let version;
+    if (options.bump) {
+        // Get latest tag and bump
+        try {
+            const latestTag = (0, child_process_1.execSync)('git describe --tags --abbrev=0 2>/dev/null || echo "v0.0.0"', {
+                encoding: 'utf-8',
+            }).trim();
+            const currentVersion = latestTag.replace(/^v/, '');
+            version = (0, adapters_go_1.normalizeVersion)((0, core_1.incrementVersion)(currentVersion, options.bump));
+        }
+        catch {
+            version = 'v0.1.0';
+        }
+    }
+    else {
+        // Get version from latest tag or default
+        try {
+            version = (0, child_process_1.execSync)('git describe --tags --abbrev=0 2>/dev/null', {
+                encoding: 'utf-8',
+            }).trim();
+            // Bump patch for new release
+            const currentVersion = version.replace(/^v/, '');
+            version = (0, adapters_go_1.normalizeVersion)((0, core_1.incrementVersion)(currentVersion, 'patch'));
+        }
+        catch {
+            version = 'v0.1.0';
+        }
+    }
+    console.log(chalk_1.default.gray('○'), `Version: ${version}`);
+    // Validate module
+    const validateSpinner = (0, ora_1.default)('Validating module...').start();
+    const tidyResult = executor.modTidy();
+    if (!tidyResult.success) {
+        validateSpinner.fail('Module validation failed');
+        if (tidyResult.stderr) {
+            console.error(chalk_1.default.gray('  '), tidyResult.stderr.trim());
+        }
+        throw new Error('go mod tidy failed');
+    }
+    validateSpinner.succeed('Module validated');
+    if (options.dryRun) {
+        console.log(chalk_1.default.yellow('→'), 'Dry-run: would create tag', version);
+        console.log(chalk_1.default.yellow('→'), 'Dry-run: would push tag to remote');
+    }
+    else {
+        // Create git tag
+        const tagSpinner = (0, ora_1.default)(`Creating tag ${version}...`).start();
+        try {
+            // Commit go.mod/go.sum if changed
+            try {
+                (0, child_process_1.execSync)('git add go.mod go.sum 2>/dev/null && git commit -m "chore: update go.mod" --allow-empty', {
+                    stdio: 'pipe',
+                });
+            }
+            catch {
+                // No changes to commit
+            }
+            (0, child_process_1.execSync)(`git tag ${version}`, { stdio: 'pipe' });
+            tagSpinner.succeed(`Created tag: ${version}`);
+        }
+        catch (error) {
+            tagSpinner.fail('Failed to create tag');
+            throw error;
+        }
+        // Push tag
+        if (options.push !== 'false') {
+            const pushSpinner = (0, ora_1.default)('Pushing to remote...').start();
+            try {
+                (0, child_process_1.execSync)('git push', { stdio: 'pipe' });
+                (0, child_process_1.execSync)('git push --tags', { stdio: 'pipe' });
+                pushSpinner.succeed('Pushed to remote');
+            }
+            catch {
+                pushSpinner.warn('Failed to push (you can push manually)');
+            }
+        }
+    }
+    console.log();
+    console.log(chalk_1.default.green('✓'), 'Publish complete!');
+    console.log(chalk_1.default.gray('Module URL:'), `https://gitlab.com/${pathWithNamespace}`);
+    console.log();
+    console.log(chalk_1.default.gray('To install:'));
+    console.log(chalk_1.default.cyan(`  go get ${modulePath}@${version}`));
+}
+/**
+ * Publish NuGet package
+ */
+async function publishNuGet(type, options) {
+    console.log(chalk_1.default.blue.bold('glpkg publish'), chalk_1.default.gray('(nuget)'));
+    console.log();
+    const tokenManager = (0, core_1.createTokenManager)();
+    const token = tokenManager.resolveToken(options.token);
+    const csprojManager = (0, adapters_nuget_1.createCsProjManager)();
+    const executor = (0, adapters_nuget_1.createCommandExecutor)();
+    // Check dotnet CLI availability
+    if (!executor.hasDotNet()) {
+        console.error(chalk_1.default.red('✗'), 'dotnet CLI not found. Please install .NET SDK.');
+        process.exit(1);
+    }
+    // Check .csproj exists
+    if (!csprojManager.exists()) {
+        console.error(chalk_1.default.red('✗'), '.csproj file not found');
+        process.exit(1);
+    }
+    // Check git status
+    if (!options.dryRun) {
+        checkGitClean(options.force);
+    }
+    // Detect project
+    const spinner = (0, ora_1.default)('Detecting project...').start();
+    let projectId;
+    let pathWithNamespace;
+    try {
+        const glabOutput = (0, child_process_1.execSync)('glab api projects/:id -X GET', { encoding: 'utf-8' });
+        const project = JSON.parse(glabOutput);
+        projectId = project.id;
+        pathWithNamespace = project.path_with_namespace;
+        spinner.succeed(`Project ID: ${projectId}`);
+    }
+    catch (error) {
+        spinner.fail('Failed to detect project');
+        throw error;
+    }
+    // Read package info
+    const csproj = csprojManager.read();
+    const packageId = csprojManager.getPackageId();
+    let version = csprojManager.getVersion();
+    // Handle version bump
+    if (options.bump) {
+        const newVersion = (0, core_1.incrementVersion)(version.replace(/-.*$/, ''), options.bump);
+        csprojManager.setVersion(newVersion);
+        console.log(chalk_1.default.gray('○'), `Version: ${version} → ${newVersion}`);
+        version = newVersion;
+    }
+    console.log(chalk_1.default.gray('○'), `Package: ${packageId}@${version}`);
+    // Build and pack
+    if (!options.noBuild) {
+        const buildSpinner = (0, ora_1.default)('Building and packing...').start();
+        const packResult = executor.pack({ configuration: 'Release' });
+        if (!packResult.success) {
+            buildSpinner.fail('Build failed');
+            if (packResult.stderr) {
+                console.error(chalk_1.default.gray('  '), packResult.stderr.trim());
+            }
+            throw new Error('dotnet pack failed');
+        }
+        buildSpinner.succeed('Build complete');
+    }
+    // Find the .nupkg file
+    const { readdirSync } = require('fs');
+    const { join } = require('path');
+    const binDir = join(process.cwd(), 'bin', 'Release');
+    let nupkgPath = null;
+    try {
+        const files = readdirSync(binDir);
+        const nupkgFile = files.find((f) => f.endsWith('.nupkg') && !f.endsWith('.symbols.nupkg'));
+        if (nupkgFile) {
+            nupkgPath = join(binDir, nupkgFile);
+        }
+    }
+    catch {
+        // Try current directory
+        const files = readdirSync(process.cwd());
+        const nupkgFile = files.find((f) => f.endsWith('.nupkg') && !f.endsWith('.symbols.nupkg'));
+        if (nupkgFile) {
+            nupkgPath = join(process.cwd(), nupkgFile);
+        }
+    }
+    if (!nupkgPath) {
+        console.error(chalk_1.default.red('✗'), '.nupkg file not found');
+        process.exit(1);
+    }
+    console.log(chalk_1.default.gray('○'), `Package: ${nupkgPath}`);
+    // Push to GitLab
+    const pushUrl = (0, adapters_nuget_1.buildProjectPushUrl)(projectId);
+    if (options.dryRun) {
+        console.log(chalk_1.default.yellow('→'), 'Dry-run: skipping push');
+        console.log(chalk_1.default.gray('  Would push to:'), pushUrl);
+    }
+    else {
+        const pushSpinner = (0, ora_1.default)('Pushing to GitLab NuGet registry...').start();
+        const pushResult = executor.push(nupkgPath, {
+            source: pushUrl,
+            apiKey: token,
+            skipDuplicate: true,
+        });
+        if (pushResult.success) {
+            pushSpinner.succeed(`Published ${packageId}@${version}`);
+            // Git operations
+            if (options.gitTag !== 'false' && type !== 'dev') {
+                createGitTag(version, csprojManager.getFilePath() || '*.csproj');
+            }
+            if (options.push !== 'false') {
+                pushToRemote(options.gitTag !== 'false' && type !== 'dev');
+            }
+        }
+        else {
+            pushSpinner.fail('Push failed');
+            if (pushResult.stderr) {
+                console.error(chalk_1.default.gray('  '), pushResult.stderr.trim());
+            }
+            throw new Error('dotnet nuget push failed');
+        }
+    }
+    console.log();
+    console.log(chalk_1.default.green('✓'), 'Publish complete!');
+    console.log(chalk_1.default.gray('Package URL:'), `https://gitlab.com/${pathWithNamespace}/-/packages`);
+}
+/**
+ * Bump version in package.json
+ */
+async function bumpVersion(pkgManager, type, bump) {
+    const currentVersion = pkgManager.getVersion();
+    let newVersion;
+    if (type === 'dev') {
+        // Dev version: x.y.z-dev.timestamp
+        const timestamp = Date.now();
+        newVersion = (0, core_1.addPrerelease)(currentVersion.replace(/-.*$/, ''), 'dev', timestamp);
+    }
+    else if (bump) {
+        const baseVersion = currentVersion.replace(/-.*$/, '');
+        newVersion = (0, core_1.incrementVersion)(baseVersion, bump);
+        if (type === 'beta') {
+            newVersion = (0, core_1.addPrerelease)(newVersion, 'beta', 0);
+        }
+    }
+    else {
+        return; // No bump needed
+    }
+    pkgManager.setVersion(newVersion);
+    console.log(chalk_1.default.gray('○'), `Version: ${currentVersion} → ${newVersion}`);
+}
+/**
+ * Check git working directory is clean
+ * Returns true if clean, false if dirty (when force mode)
+ */
+function checkGitClean(force = false) {
+    try {
+        const status = (0, child_process_1.execSync)('git status --porcelain', { encoding: 'utf-8' });
+        if (status.trim()) {
+            if (force) {
+                console.log(chalk_1.default.yellow('⚠'), 'Git working directory is not clean');
+                console.log(chalk_1.default.yellow('  →'), chalk_1.default.bold('It is strongly recommended to commit your changes before publishing'));
+                console.log(chalk_1.default.gray('    Continuing with --force...'));
+                console.log();
+                return false;
+            }
+            else {
+                console.error(chalk_1.default.red('✗'), 'Git working directory is not clean');
+                console.error(chalk_1.default.yellow('→'), 'Commit or stash changes, or use --force');
+                process.exit(1);
+            }
+        }
+        return true;
+    }
+    catch {
+        // Not a git repo, skip check
+        return true;
+    }
+}
+/**
+ * Create git tag
+ */
+function createGitTag(version, manifestFile = 'package.json') {
+    try {
+        (0, child_process_1.execSync)(`git add ${manifestFile} && git commit -m "chore: release v${version}" --allow-empty`, {
+            stdio: 'pipe',
+        });
+        (0, child_process_1.execSync)(`git tag v${version}`, { stdio: 'pipe' });
+        console.log(chalk_1.default.gray('○'), `Created tag: v${version}`);
+    }
+    catch {
+        // Ignore errors
+    }
+}
+/**
+ * Push to remote
+ */
+function pushToRemote(includeTags) {
+    try {
+        (0, child_process_1.execSync)('git push', { stdio: 'pipe' });
+        if (includeTags) {
+            (0, child_process_1.execSync)('git push --tags', { stdio: 'pipe' });
+        }
+        console.log(chalk_1.default.gray('○'), 'Pushed to remote');
+    }
+    catch {
+        console.log(chalk_1.default.yellow('⚠'), 'Failed to push (you can push manually)');
+    }
+}
+//# sourceMappingURL=publish.js.map