@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/clients/git-client.js

@@ -0,0 +1,367 @@
+/**
+ * Git Tools Client
+ *
+ * REST client for communicating with the Git Tools Service
+ */
+import { RestClient, ServiceURLs } from '.';
+/**
+ * Client for Git Tools Service
+ */
+export class GitClient {
+    client;
+    constructor(baseUrl) {
+        this.client = new RestClient(baseUrl || ServiceURLs.GIT_TOOLS);
+    }
+    /**
+     * Get git status
+     */
+    async status(directory) {
+        const params = new URLSearchParams();
+        if (directory) {
+            params.set('directory', directory);
+        }
+        const response = await this.client.get(`/api/git/status?${params.toString()}`);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return {
+            success: false,
+            status: {
+                branch: '',
+                ahead: 0,
+                behind: 0,
+                staged: [],
+                modified: [],
+                untracked: [],
+                deleted: [],
+            },
+            error: response.error?.message || 'Unknown error',
+        };
+    }
+    /**
+     * Stage files
+     */
+    async add(files, options) {
+        const response = await this.client.post('/api/git/add', { files, ...options });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Create a commit
+     */
+    async commit(message, options) {
+        const response = await this.client.post('/api/git/commit', { message, ...options });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return {
+            success: false,
+            commit: { hash: '', shortHash: '', message: '', author: '', date: '' },
+            error: response.error?.message || 'Unknown error',
+        };
+    }
+    /**
+     * Push to remote
+     */
+    async push(options) {
+        const response = await this.client.post('/api/git/push', options || {});
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Pull from remote
+     */
+    async pull(options) {
+        const response = await this.client.post('/api/git/pull', options || {});
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Fetch from remote
+     */
+    async fetch(options) {
+        const response = await this.client.post('/api/git/fetch', options || {});
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Get commit log
+     */
+    async log(options) {
+        const params = new URLSearchParams();
+        if (options?.directory) {
+            params.set('directory', options.directory);
+        }
+        if (options?.limit) {
+            params.set('limit', String(options.limit));
+        }
+        if (options?.branch) {
+            params.set('branch', options.branch);
+        }
+        const response = await this.client.get(`/api/git/log?${params.toString()}`);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, commits: [], error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * List branches
+     */
+    async branches(options) {
+        const params = new URLSearchParams();
+        if (options?.directory) {
+            params.set('directory', options.directory);
+        }
+        if (options?.all) {
+            params.set('all', 'true');
+        }
+        const response = await this.client.get(`/api/git/branches?${params.toString()}`);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, branches: [], error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Checkout branch or file
+     */
+    async checkout(target, options) {
+        const response = await this.client.post('/api/git/checkout', { target, ...options });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Get diff
+     */
+    async diff(options) {
+        const params = new URLSearchParams();
+        if (options?.directory) {
+            params.set('directory', options.directory);
+        }
+        if (options?.staged) {
+            params.set('staged', 'true');
+        }
+        if (options?.file) {
+            params.set('file', options.file);
+        }
+        const response = await this.client.get(`/api/git/diff?${params.toString()}`);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, diff: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Merge a branch
+     */
+    async merge(branch, options) {
+        const response = await this.client.post('/api/git/merge', { branch, ...options });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Stash operations
+     */
+    async stash(command, options) {
+        const response = await this.client.post('/api/git/stash', { command, ...options });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Clone a repository
+     */
+    async clone(url, targetPath, options) {
+        const response = await this.client.post('/api/git/clone', { url, path: targetPath, ...options });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Tag operations
+     */
+    async tagCreate(name, options) {
+        const response = await this.client.post('/api/git/tag', { name, path: options?.directory, ...options });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    async tagDelete(name, options) {
+        const params = new URLSearchParams();
+        params.set('name', name);
+        if (options?.directory) {
+            params.set('path', options.directory);
+        }
+        const response = await this.client.delete(`/api/git/tag?${params.toString()}`);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    async tagList(options) {
+        const params = new URLSearchParams();
+        if (options?.directory) {
+            params.set('path', options.directory);
+        }
+        if (options?.pattern) {
+            params.set('pattern', options.pattern);
+        }
+        const response = await this.client.get(`/api/git/tags?${params.toString()}`);
+        if (response.success && response.data) {
+            const data = response.data;
+            return { success: true, tags: data?.data?.tags || data?.tags || [] };
+        }
+        return { success: false, tags: [], error: response.error?.message || 'Unknown error' };
+    }
+    async tagPush(options) {
+        const response = await this.client.post('/api/git/tag/push', { path: options?.directory, remote: options?.remote, tagName: options?.tagName });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    async tagShow(name, options) {
+        const params = new URLSearchParams();
+        params.set('name', name);
+        if (options?.directory) {
+            params.set('path', options.directory);
+        }
+        const response = await this.client.get(`/api/git/tag/show?${params.toString()}`);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Get remote URL
+     */
+    async remote(remoteName, options) {
+        const params = new URLSearchParams();
+        if (options?.directory) {
+            params.set('path', options.directory);
+        }
+        if (remoteName) {
+            params.set('name', remoteName);
+        }
+        const response = await this.client.get(`/api/git/remote?${params.toString()}`);
+        if (response.success && response.data) {
+            const data = response.data;
+            return {
+                success: true,
+                remote: data?.data?.remote || data?.remote || remoteName || 'origin',
+                url: data?.data?.url !== undefined ? data.data.url : data?.url,
+            };
+        }
+        return {
+            success: false,
+            remote: remoteName || 'origin',
+            url: null,
+            error: response.error?.message || 'Unknown error',
+        };
+    }
+    /**
+     * Reset to a commit
+     */
+    async reset(target, options) {
+        const response = await this.client.post('/api/git/reset', { target, path: options?.directory, mode: options?.mode });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Revert a commit
+     */
+    async revert(commit, options) {
+        const response = await this.client.post('/api/git/revert', { commit, cwd: options?.directory, noCommit: options?.noCommit, noEdit: options?.noEdit });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Cherry-pick operations
+     */
+    async cherryPick(commit, options) {
+        const response = await this.client.post('/api/git/cherry-pick', { commit, path: options?.directory, noCommit: options?.noCommit });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    async cherryPickAbort(options) {
+        const response = await this.client.post('/api/git/cherry-pick/abort', { path: options?.directory });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    async cherryPickContinue(options) {
+        const response = await this.client.post('/api/git/cherry-pick/continue', { path: options?.directory });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Blame a file
+     */
+    async blame(file, options) {
+        const params = new URLSearchParams();
+        params.set('file', file);
+        if (options?.directory) {
+            params.set('path', options.directory);
+        }
+        if (options?.lineRange) {
+            const parts = options.lineRange.split(',');
+            if (parts[0]) {
+                params.set('startLine', parts[0].trim());
+            }
+            if (parts[1]) {
+                params.set('endLine', parts[1].trim());
+            }
+        }
+        const response = await this.client.get(`/api/git/blame?${params.toString()}`);
+        if (response.success && response.data) {
+            const data = response.data;
+            return { success: true, blame: data?.data?.blame || data?.blame || [] };
+        }
+        return { success: false, blame: [], error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Initialize a repository
+     */
+    async init(options) {
+        const response = await this.client.post('/api/git/init', { path: options?.directory, bare: options?.bare });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, output: '', error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Check if service is available
+     */
+    async isAvailable() {
+        try {
+            const response = await this.client.get('/health');
+            return response.success && response.data?.status === 'healthy';
+        }
+        catch {
+            return false;
+        }
+    }
+}
+export const gitClient = new GitClient();

package/dist/src/clients/github-client.js

@@ -0,0 +1,229 @@
+/**
+ * GitHub Tools Client
+ *
+ * REST client for communicating with the GitHub Tools Service
+ */
+import { RestClient, ServiceURLs } from '.';
+import { authStore } from '../auth/store';
+/**
+ * Client for GitHub Tools Service
+ */
+export class GitHubClient {
+    client;
+    baseUrl;
+    constructor(baseUrl) {
+        this.baseUrl = baseUrl || ServiceURLs.GITHUB_TOOLS;
+        this.client = new RestClient(this.baseUrl);
+    }
+    /**
+     * Get authorization header from stored GitHub identity
+     */
+    getAuthHeader() {
+        const identity = authStore.getIdentity();
+        if (identity?.accessToken) {
+            return { Authorization: `Bearer ${identity.accessToken}` };
+        }
+        return {};
+    }
+    /**
+     * Create a REST client with auth headers
+     */
+    getAuthClient() {
+        const authHeaders = this.getAuthHeader();
+        return new RestClient(this.baseUrl, {
+            headers: authHeaders,
+        });
+    }
+    /**
+     * Get authenticated user info
+     */
+    async getUser() {
+        const client = this.getAuthClient();
+        const response = await client.get('/api/github/user');
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * List pull requests
+     */
+    async listPRs(owner, repo, options) {
+        const client = this.getAuthClient();
+        const params = new URLSearchParams();
+        params.set('owner', owner);
+        params.set('repo', repo);
+        if (options?.state) {
+            params.set('state', options.state);
+        }
+        if (options?.perPage) {
+            params.set('per_page', String(options.perPage));
+        }
+        const response = await client.get(`/api/github/prs?${params.toString()}`);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Get a single pull request
+     */
+    async getPR(owner, repo, prNumber) {
+        const client = this.getAuthClient();
+        const params = new URLSearchParams();
+        params.set('owner', owner);
+        params.set('repo', repo);
+        const response = await client.get(`/api/github/prs/${prNumber}?${params.toString()}`);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Create a pull request
+     */
+    async createPR(owner, repo, params) {
+        const client = this.getAuthClient();
+        const response = await client.post('/api/github/prs', { owner, repo, ...params });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Merge a pull request
+     */
+    async mergePR(owner, repo, prNumber, options) {
+        const client = this.getAuthClient();
+        const response = await client.post(`/api/github/prs/${prNumber}/merge`, { owner, repo, ...options });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Create a review on a pull request
+     */
+    async createPRReview(owner, repo, prNumber, event, body) {
+        const client = this.getAuthClient();
+        const response = await client.post(`/api/github/prs/${prNumber}/reviews`, { owner, repo, event, body });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * List issues
+     */
+    async listIssues(owner, repo, options) {
+        const client = this.getAuthClient();
+        const params = new URLSearchParams();
+        params.set('owner', owner);
+        params.set('repo', repo);
+        if (options?.state) {
+            params.set('state', options.state);
+        }
+        if (options?.perPage) {
+            params.set('per_page', String(options.perPage));
+        }
+        const response = await client.get(`/api/github/issues?${params.toString()}`);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Get a single issue
+     */
+    async getIssue(owner, repo, issueNumber) {
+        const client = this.getAuthClient();
+        const params = new URLSearchParams();
+        params.set('owner', owner);
+        params.set('repo', repo);
+        const response = await client.get(`/api/github/issues/${issueNumber}?${params.toString()}`);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Create an issue
+     */
+    async createIssue(owner, repo, params) {
+        const client = this.getAuthClient();
+        const response = await client.post('/api/github/issues', { owner, repo, ...params });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Close an issue
+     */
+    async closeIssue(owner, repo, issueNumber) {
+        const client = this.getAuthClient();
+        const params = new URLSearchParams();
+        params.set('owner', owner);
+        params.set('repo', repo);
+        const response = await client.put(`/api/github/issues/${issueNumber}/close?${params.toString()}`, {});
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Add a comment to an issue or PR
+     */
+    async addComment(owner, repo, issueNumber, body) {
+        const client = this.getAuthClient();
+        const response = await client.post(`/api/github/issues/${issueNumber}/comments`, { owner, repo, body });
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Get repository info
+     */
+    async getRepo(owner, repo) {
+        const client = this.getAuthClient();
+        const params = new URLSearchParams();
+        params.set('owner', owner);
+        params.set('repo', repo);
+        const response = await client.get(`/api/github/repos?${params.toString()}`);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * List branches
+     */
+    async listBranches(owner, repo, options) {
+        const client = this.getAuthClient();
+        const params = new URLSearchParams();
+        params.set('owner', owner);
+        params.set('repo', repo);
+        if (options?.perPage) {
+            params.set('per_page', String(options.perPage));
+        }
+        const response = await client.get(`/api/github/repos/branches?${params.toString()}`);
+        if (response.success && response.data) {
+            return response.data;
+        }
+        return { success: false, error: response.error?.message || 'Unknown error' };
+    }
+    /**
+     * Check if service is available
+     */
+    async isAvailable() {
+        try {
+            const response = await this.client.get('/health');
+            return response.success && response.data?.status === 'healthy';
+        }
+        catch {
+            return false;
+        }
+    }
+}
+export const githubClient = new GitHubClient();