@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/tools/git-ops.js

@@ -0,0 +1,557 @@
+/**
+ * Git Operations — Embedded tool (stripped HTTP wrappers)
+ *
+ * Copied from services/git-tools-service/src/git/operations.ts
+ * Provides direct git operations for the embedded CLI binary.
+ */
+import simpleGit from 'simple-git';
+import { logger } from '../utils';
+export class GitOperations {
+    git;
+    repoPath;
+    constructor(repoPath = process.cwd()) {
+        this.repoPath = repoPath;
+        const options = {
+            baseDir: repoPath,
+            binary: 'git',
+            maxConcurrentProcesses: 6,
+            trimmed: true,
+        };
+        this.git = simpleGit(options);
+    }
+    /**
+     * Clone a repository
+     */
+    async clone(options) {
+        logger.info(`Cloning repository from ${options.url} to ${options.path}`);
+        const cloneOptions = [];
+        if (options.branch) {
+            cloneOptions.push('--branch', options.branch);
+        }
+        if (options.depth) {
+            cloneOptions.push('--depth', options.depth.toString());
+        }
+        await simpleGit().clone(options.url, options.path, cloneOptions);
+        return { success: true, path: options.path };
+    }
+    /**
+     * Get repository status
+     */
+    async status() {
+        logger.info(`Getting git status for ${this.repoPath}`);
+        return await this.git.status();
+    }
+    /**
+     * Add files to staging
+     */
+    async add(files = '.') {
+        const fileList = Array.isArray(files) ? files : [files];
+        logger.info(`Staging files: ${fileList.join(', ')}`);
+        await this.git.add(fileList);
+        return { success: true, files: fileList };
+    }
+    /**
+     * Commit staged changes
+     */
+    async commit(options) {
+        logger.info(`Committing with message: ${options.message}`);
+        const commitOptions = [];
+        if (options.amend) {
+            commitOptions.push('--amend');
+        }
+        if (options.allowEmpty) {
+            commitOptions.push('--allow-empty');
+        }
+        const result = await this.git.commit(options.message, undefined, { '--': commitOptions });
+        return {
+            success: true,
+            hash: result.commit,
+            summary: result.summary
+                ? `${result.summary.changes} changes, ${result.summary.insertions} insertions, ${result.summary.deletions} deletions`
+                : 'Committed',
+        };
+    }
+    /**
+     * Push to remote
+     */
+    async push(options = {}) {
+        const remote = options.remote || 'origin';
+        logger.info(`Pushing to ${remote}${options.branch ? `/${options.branch}` : ''}`);
+        const pushOptions = [];
+        if (options.force) {
+            pushOptions.push('--force');
+        }
+        if (options.setUpstream) {
+            pushOptions.push('--set-upstream');
+        }
+        await this.git.push(remote, options.branch, pushOptions);
+        return { success: true, remote, branch: options.branch || 'current' };
+    }
+    /**
+     * Pull from remote
+     */
+    async pull(options = {}) {
+        const remote = options.remote || 'origin';
+        logger.info(`Pulling from ${remote}${options.branch ? `/${options.branch}` : ''}`);
+        const pullOptions = {};
+        if (options.rebase) {
+            pullOptions['--rebase'] = null;
+        }
+        const result = await this.git.pull(remote, options.branch, pullOptions);
+        return {
+            success: true,
+            summary: result.summary
+                ? `${result.summary.changes} changes, ${result.summary.insertions} insertions, ${result.summary.deletions} deletions`
+                : 'Already up to date',
+        };
+    }
+    /**
+     * Create a new branch
+     */
+    async createBranch(options) {
+        logger.info(`Creating branch: ${options.name}`);
+        if (options.checkout) {
+            if (options.startPoint) {
+                await this.git.checkoutBranch(options.name, options.startPoint);
+            }
+            else {
+                await this.git.checkoutLocalBranch(options.name);
+            }
+        }
+        else {
+            await this.git.branch([options.name, options.startPoint || 'HEAD']);
+        }
+        return { success: true, branch: options.name };
+    }
+    /**
+     * List branches
+     */
+    async listBranches(showRemote = false) {
+        logger.info('Listing branches');
+        const result = await this.git.branch(showRemote ? ['-a'] : []);
+        return {
+            current: result.current,
+            branches: result.all,
+        };
+    }
+    /**
+     * Checkout a branch or commit
+     */
+    async checkout(target, create = false) {
+        logger.info(`Checking out: ${target}`);
+        if (create) {
+            await this.git.checkoutLocalBranch(target);
+        }
+        else {
+            await this.git.checkout(target);
+        }
+        return { success: true, target };
+    }
+    /**
+     * Get diff
+     */
+    async diff(options = {}) {
+        logger.info('Getting diff');
+        const diffArgs = [];
+        if (options.cached) {
+            diffArgs.push('--cached');
+        }
+        if (options.nameOnly) {
+            diffArgs.push('--name-only');
+        }
+        if (options.from) {
+            diffArgs.push(options.from);
+        }
+        if (options.to) {
+            diffArgs.push(options.to);
+        }
+        const diff = await this.git.diff(diffArgs);
+        const files = options.nameOnly ? diff.split('\n').filter(f => f) : [];
+        return { diff, files };
+    }
+    /**
+     * Get commit log
+     */
+    async log(options = {}) {
+        logger.info('Getting commit log');
+        const logOptions = {};
+        if (options.maxCount) {
+            logOptions.maxCount = options.maxCount;
+        }
+        if (options.from) {
+            logOptions.from = options.from;
+        }
+        if (options.to) {
+            logOptions.to = options.to;
+        }
+        if (options.file) {
+            logOptions.file = options.file;
+        }
+        return await this.git.log(logOptions);
+    }
+    /**
+     * Merge a branch
+     */
+    async merge(options) {
+        logger.info(`Merging branch: ${options.branch}`);
+        const mergeArgs = [options.branch];
+        if (options.noFf) {
+            mergeArgs.unshift('--no-ff');
+        }
+        if (options.squash) {
+            mergeArgs.unshift('--squash');
+        }
+        if (options.message) {
+            mergeArgs.unshift('-m', options.message);
+        }
+        const result = await this.git.merge(mergeArgs);
+        return {
+            success: true,
+            result: result.result || 'Merged successfully',
+        };
+    }
+    /**
+     * Stash operations
+     */
+    async stash(options) {
+        logger.info(`Stash operation: ${options.command}`);
+        let result;
+        switch (options.command) {
+            case 'push': {
+                const pushArgs = options.message ? ['-m', options.message] : [];
+                result = await this.git.stash(['push', ...pushArgs]);
+                break;
+            }
+            case 'pop':
+                result = await this.git.stash([
+                    'pop',
+                    ...(options.index !== undefined ? [options.index.toString()] : []),
+                ]);
+                break;
+            case 'apply':
+                result = await this.git.stash([
+                    'apply',
+                    ...(options.index !== undefined ? [options.index.toString()] : []),
+                ]);
+                break;
+            case 'drop':
+                result = await this.git.stash([
+                    'drop',
+                    ...(options.index !== undefined ? [options.index.toString()] : []),
+                ]);
+                break;
+            case 'list':
+                result = await this.git.stash(['list']);
+                break;
+            case 'clear':
+                result = await this.git.stash(['clear']);
+                break;
+            default:
+                throw new Error(`Unknown stash command: ${options.command}`);
+        }
+        return { success: true, result: result || 'Stash operation completed' };
+    }
+    /**
+     * Get current branch name
+     */
+    async currentBranch() {
+        const result = await this.git.revparse(['--abbrev-ref', 'HEAD']);
+        return result.trim();
+    }
+    /**
+     * Check if repository is clean
+     */
+    async isClean() {
+        const status = await this.status();
+        return status.isClean();
+    }
+    /**
+     * Reset to a commit
+     */
+    async reset(target, mode = 'mixed') {
+        logger.info(`Resetting to ${target} with mode ${mode}`);
+        await this.git.reset([`--${mode}`, target]);
+        return { success: true };
+    }
+    /**
+     * Fetch from remote
+     */
+    async fetch(remote = 'origin', prune = false) {
+        logger.info(`Fetching from ${remote}`);
+        if (prune) {
+            await this.git.fetch(remote, ['--prune']);
+        }
+        else {
+            await this.git.fetch(remote);
+        }
+        return { success: true };
+    }
+    /**
+     * Get remote URL
+     */
+    async getRemoteUrl(remote = 'origin') {
+        try {
+            const remotes = await this.git.getRemotes(true);
+            const targetRemote = remotes.find(r => r.name === remote);
+            return targetRemote?.refs?.fetch || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Check if path is a git repository
+     */
+    async isRepo() {
+        return await this.git.checkIsRepo();
+    }
+    /**
+     * Initialize a new repository
+     */
+    async init(bare = false) {
+        logger.info(`Initializing git repository in ${this.repoPath}`);
+        await this.git.init(bare);
+        return { success: true };
+    }
+    /**
+     * Cherry-pick a commit
+     */
+    async cherryPick(commit, options = {}) {
+        logger.info(`Cherry-picking commit: ${commit}`);
+        const cherryPickArgs = [commit];
+        if (options.noCommit) {
+            cherryPickArgs.unshift('--no-commit');
+        }
+        if (options.edit) {
+            cherryPickArgs.unshift('-e');
+        }
+        if (options.signoff) {
+            cherryPickArgs.unshift('-s');
+        }
+        if (options.strategy) {
+            cherryPickArgs.unshift('-X', options.strategy);
+        }
+        // Use raw to execute cherry-pick
+        const result = await this.git.raw(['cherry-pick', ...cherryPickArgs]);
+        return {
+            success: true,
+            result: result || 'Cherry-pick completed successfully',
+        };
+    }
+    /**
+     * Rebase onto a target branch
+     */
+    async rebase(target, options = {}) {
+        logger.info(`Rebasing onto: ${target}`);
+        const rebaseArgs = [];
+        if (options.interactive) {
+            // Note: Interactive rebase requires a terminal, so we skip it in automation
+            logger.warn('Interactive rebase not supported in automation mode');
+        }
+        if (options.onto) {
+            rebaseArgs.push('--onto', options.onto);
+        }
+        if (options.preserveMerges) {
+            rebaseArgs.push('--preserve-merges');
+        }
+        if (options.strategy) {
+            rebaseArgs.push('-s', options.strategy);
+        }
+        if (options.strategyOption) {
+            rebaseArgs.push('-X', options.strategyOption);
+        }
+        rebaseArgs.push(target);
+        const result = await this.git.rebase(rebaseArgs);
+        return {
+            success: true,
+            result: result || 'Rebase completed successfully',
+        };
+    }
+    /**
+     * Continue a rebase after resolving conflicts
+     */
+    async rebaseContinue() {
+        logger.info('Continuing rebase');
+        const result = await this.git.rebase(['--continue']);
+        return {
+            success: true,
+            result: result || 'Rebase continued successfully',
+        };
+    }
+    /**
+     * Abort a rebase in progress
+     */
+    async rebaseAbort() {
+        logger.info('Aborting rebase');
+        await this.git.rebase(['--abort']);
+        return { success: true };
+    }
+    /**
+     * Skip a commit during rebase
+     */
+    async rebaseSkip() {
+        logger.info('Skipping commit during rebase');
+        const result = await this.git.rebase(['--skip']);
+        return {
+            success: true,
+            result: result || 'Commit skipped',
+        };
+    }
+    /**
+     * Create a tag
+     */
+    async tag(name, options = {}) {
+        logger.info(`Creating tag: ${name}`);
+        const tagArgs = [];
+        if (options.annotated || options.message) {
+            tagArgs.push('-a');
+        }
+        if (options.message) {
+            tagArgs.push('-m', options.message);
+        }
+        if (options.force) {
+            tagArgs.push('-f');
+        }
+        tagArgs.push(name);
+        if (options.commit) {
+            tagArgs.push(options.commit);
+        }
+        await this.git.tag(tagArgs);
+        return { success: true, tag: name };
+    }
+    /**
+     * Delete a tag
+     */
+    async deleteTag(name, remote) {
+        logger.info(`Deleting tag: ${name}`);
+        // Delete locally
+        await this.git.tag(['-d', name]);
+        // Delete from remote if specified
+        if (remote) {
+            await this.git.push(remote, `:refs/tags/${name}`);
+        }
+        return { success: true };
+    }
+    /**
+     * List tags
+     */
+    async listTags(pattern) {
+        logger.info('Listing tags');
+        const args = pattern ? ['-l', pattern] : [];
+        const result = await this.git.tags(args);
+        return result.all;
+    }
+    /**
+     * Push tags to remote
+     */
+    async pushTags(remote = 'origin', tagName) {
+        logger.info(`Pushing tags to ${remote}`);
+        if (tagName) {
+            await this.git.push(remote, `refs/tags/${tagName}`);
+        }
+        else {
+            await this.git.pushTags(remote);
+        }
+        return { success: true };
+    }
+    /**
+     * Show information about a tag
+     */
+    async showTag(name) {
+        logger.info(`Showing tag: ${name}`);
+        const result = await this.git.show(['--no-patch', name]);
+        return { success: true, info: result };
+    }
+    /**
+     * Check if there are conflicts
+     */
+    async hasConflicts() {
+        const status = await this.status();
+        return status.conflicted.length > 0;
+    }
+    /**
+     * Get list of conflicted files
+     */
+    async getConflicts() {
+        const status = await this.status();
+        return status.conflicted;
+    }
+    /**
+     * Abort cherry-pick in progress
+     */
+    async cherryPickAbort() {
+        logger.info('Aborting cherry-pick');
+        await this.git.raw(['cherry-pick', '--abort']);
+        return { success: true };
+    }
+    /**
+     * Continue cherry-pick after resolving conflicts
+     */
+    async cherryPickContinue() {
+        logger.info('Continuing cherry-pick');
+        const result = await this.git.raw(['cherry-pick', '--continue']);
+        return {
+            success: true,
+            result: result || 'Cherry-pick continued',
+        };
+    }
+    /**
+     * Show a specific commit
+     */
+    async showCommit(commit) {
+        logger.info(`Showing commit: ${commit}`);
+        return await this.git.show([commit]);
+    }
+    /**
+     * Get the short hash for a ref
+     */
+    async getShortHash(ref = 'HEAD') {
+        const result = await this.git.revparse(['--short', ref]);
+        return result.trim();
+    }
+    /**
+     * Get the full hash for a ref
+     */
+    async getFullHash(ref = 'HEAD') {
+        const result = await this.git.revparse([ref]);
+        return result.trim();
+    }
+    /**
+     * Get the commit count between two refs
+     */
+    async getCommitCount(from, to = 'HEAD') {
+        const result = await this.git.raw(['rev-list', '--count', `${from}..${to}`]);
+        return parseInt(result.trim(), 10);
+    }
+    /**
+     * Revert a commit
+     */
+    async revert(commit, options = {}) {
+        logger.info(`Reverting commit: ${commit}`);
+        const revertArgs = [];
+        if (options.noCommit) {
+            revertArgs.push('--no-commit');
+        }
+        if (options.noEdit) {
+            revertArgs.push('--no-edit');
+        }
+        revertArgs.push(commit);
+        const result = await this.git.raw(['revert', ...revertArgs]);
+        return {
+            success: true,
+            result: result || 'Revert completed successfully',
+        };
+    }
+    /**
+     * Blame a file
+     */
+    async blame(file, options) {
+        logger.info(`Getting blame for: ${file}`);
+        const args = [];
+        if (options?.startLine && options?.endLine) {
+            args.push(`-L${options.startLine},${options.endLine}`);
+        }
+        args.push(file);
+        return await this.git.raw(['blame', ...args]);
+    }
+}