@build-astron-co/nimbus 0.2.0 → 0.4.0

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

@@ -0,0 +1,1227 @@
+import { RestClient } from './rest-client';
+import { ServiceURLs } from './service-discovery';
+/**
+ * Unified Tools Client for MCP Tools Services
+ * Provides a single interface to interact with all tool services
+ */
+export class ToolsClient {
+    gitClient;
+    fsClient;
+    terraformClient;
+    k8sClient;
+    helmClient;
+    awsClient;
+    githubClient;
+    gcpClient;
+    azureClient;
+    constructor(options = {}) {
+        this.gitClient = new RestClient(ServiceURLs.GIT_TOOLS, options);
+        this.fsClient = new RestClient(ServiceURLs.FS_TOOLS, options);
+        this.terraformClient = new RestClient(ServiceURLs.TERRAFORM_TOOLS, options);
+        this.k8sClient = new RestClient(ServiceURLs.K8S_TOOLS, options);
+        this.helmClient = new RestClient(ServiceURLs.HELM_TOOLS, options);
+        this.awsClient = new RestClient(ServiceURLs.AWS_TOOLS, options);
+        this.githubClient = new RestClient(ServiceURLs.GITHUB_TOOLS, options);
+        this.gcpClient = new RestClient(ServiceURLs.GCP_TOOLS, options);
+        this.azureClient = new RestClient(ServiceURLs.AZURE_TOOLS, options);
+    }
+    // ==================== Git Operations ====================
+    git = {
+        clone: async (url, path, options) => {
+            return this.gitClient.post('/api/git/clone', { url, path, ...options });
+        },
+        status: async (path) => {
+            const query = path ? `?path=${encodeURIComponent(path)}` : '';
+            return this.gitClient.get(`/api/git/status${query}`);
+        },
+        add: async (files, path) => {
+            return this.gitClient.post('/api/git/add', { files, path });
+        },
+        commit: async (message, options) => {
+            return this.gitClient.post('/api/git/commit', { message, ...options });
+        },
+        push: async (options) => {
+            return this.gitClient.post('/api/git/push', options);
+        },
+        pull: async (options) => {
+            return this.gitClient.post('/api/git/pull', options);
+        },
+        createBranch: async (name, options) => {
+            return this.gitClient.post('/api/git/branch', { name, ...options });
+        },
+        listBranches: async (path, showRemote) => {
+            const params = new URLSearchParams();
+            if (path) {
+                params.set('path', path);
+            }
+            if (showRemote) {
+                params.set('remote', 'true');
+            }
+            const query = params.toString() ? `?${params.toString()}` : '';
+            return this.gitClient.get(`/api/git/branches${query}`);
+        },
+        checkout: async (target, options) => {
+            return this.gitClient.post('/api/git/checkout', { target, ...options });
+        },
+        diff: async (options) => {
+            const params = new URLSearchParams();
+            if (options?.path) {
+                params.set('path', options.path);
+            }
+            if (options?.cached) {
+                params.set('cached', 'true');
+            }
+            if (options?.nameOnly) {
+                params.set('nameOnly', 'true');
+            }
+            if (options?.from) {
+                params.set('from', options.from);
+            }
+            if (options?.to) {
+                params.set('to', options.to);
+            }
+            const query = params.toString() ? `?${params.toString()}` : '';
+            return this.gitClient.get(`/api/git/diff${query}`);
+        },
+        log: async (options) => {
+            const params = new URLSearchParams();
+            if (options?.path) {
+                params.set('path', options.path);
+            }
+            if (options?.maxCount) {
+                params.set('maxCount', options.maxCount.toString());
+            }
+            if (options?.from) {
+                params.set('from', options.from);
+            }
+            if (options?.to) {
+                params.set('to', options.to);
+            }
+            if (options?.file) {
+                params.set('file', options.file);
+            }
+            const query = params.toString() ? `?${params.toString()}` : '';
+            return this.gitClient.get(`/api/git/log${query}`);
+        },
+        merge: async (branch, options) => {
+            return this.gitClient.post('/api/git/merge', { branch, ...options });
+        },
+        stash: async (command, options) => {
+            return this.gitClient.post('/api/git/stash', { command, ...options });
+        },
+        fetch: async (options) => {
+            return this.gitClient.post('/api/git/fetch', options);
+        },
+        reset: async (target, options) => {
+            return this.gitClient.post('/api/git/reset', { target, ...options });
+        },
+        init: async (options) => {
+            return this.gitClient.post('/api/git/init', options);
+        },
+        remote: async (options) => {
+            const params = new URLSearchParams();
+            if (options?.path) {
+                params.set('path', options.path);
+            }
+            if (options?.name) {
+                params.set('name', options.name);
+            }
+            const query = params.toString() ? `?${params.toString()}` : '';
+            return this.gitClient.get(`/api/git/remote${query}`);
+        },
+        revert: async (commit, options) => {
+            return this.gitClient.post('/api/git/revert', { commit, ...options });
+        },
+        cherryPick: async (commit, options) => {
+            return this.gitClient.post('/api/git/cherry-pick', { commit, ...options });
+        },
+        cherryPickAbort: async (options) => {
+            return this.gitClient.post('/api/git/cherry-pick/abort', options || {});
+        },
+        cherryPickContinue: async (options) => {
+            return this.gitClient.post('/api/git/cherry-pick/continue', options || {});
+        },
+        tag: async (name, options) => {
+            return this.gitClient.post('/api/git/tag', { name, ...options });
+        },
+        deleteTag: async (name, options) => {
+            const params = new URLSearchParams();
+            params.set('name', name);
+            if (options?.path) {
+                params.set('path', options.path);
+            }
+            if (options?.remote) {
+                params.set('remote', options.remote);
+            }
+            return this.gitClient.delete(`/api/git/tag?${params.toString()}`);
+        },
+        listTags: async (options) => {
+            const params = new URLSearchParams();
+            if (options?.path) {
+                params.set('path', options.path);
+            }
+            if (options?.pattern) {
+                params.set('pattern', options.pattern);
+            }
+            const query = params.toString() ? `?${params.toString()}` : '';
+            return this.gitClient.get(`/api/git/tags${query}`);
+        },
+        pushTags: async (options) => {
+            return this.gitClient.post('/api/git/tag/push', options || {});
+        },
+        showTag: async (name, options) => {
+            const params = new URLSearchParams();
+            params.set('name', name);
+            if (options?.path) {
+                params.set('path', options.path);
+            }
+            return this.gitClient.get(`/api/git/tag/show?${params.toString()}`);
+        },
+        blame: async (file, options) => {
+            const params = new URLSearchParams();
+            params.set('file', file);
+            if (options?.path) {
+                params.set('path', options.path);
+            }
+            if (options?.startLine) {
+                params.set('startLine', options.startLine.toString());
+            }
+            if (options?.endLine) {
+                params.set('endLine', options.endLine.toString());
+            }
+            return this.gitClient.get(`/api/git/blame?${params.toString()}`);
+        },
+    };
+    // ==================== File System Operations ====================
+    fs = {
+        read: async (filePath, options) => {
+            const params = new URLSearchParams();
+            params.set('path', filePath);
+            if (options?.basePath) {
+                params.set('basePath', options.basePath);
+            }
+            if (options?.encoding) {
+                params.set('encoding', options.encoding);
+            }
+            return this.fsClient.get(`/api/fs/read?${params.toString()}`);
+        },
+        write: async (filePath, content, options) => {
+            return this.fsClient.post('/api/fs/write', { path: filePath, content, ...options });
+        },
+        list: async (dirPath, options) => {
+            const params = new URLSearchParams();
+            params.set('path', dirPath);
+            if (options?.basePath) {
+                params.set('basePath', options.basePath);
+            }
+            if (options?.recursive) {
+                params.set('recursive', 'true');
+            }
+            if (options?.pattern) {
+                params.set('pattern', options.pattern);
+            }
+            return this.fsClient.get(`/api/fs/list?${params.toString()}`);
+        },
+        search: async (pattern, options) => {
+            const params = new URLSearchParams();
+            params.set('pattern', pattern);
+            if (options?.basePath) {
+                params.set('basePath', options.basePath);
+            }
+            if (options?.path) {
+                params.set('path', options.path);
+            }
+            if (options?.type) {
+                params.set('type', options.type);
+            }
+            if (options?.maxResults) {
+                params.set('maxResults', options.maxResults.toString());
+            }
+            return this.fsClient.get(`/api/fs/search?${params.toString()}`);
+        },
+        delete: async (filePath, options) => {
+            return this.fsClient.post('/api/fs/delete', { path: filePath, ...options });
+        },
+        copy: async (source, destination, options) => {
+            return this.fsClient.post('/api/fs/copy', { source, destination, ...options });
+        },
+        move: async (source, destination, options) => {
+            return this.fsClient.post('/api/fs/move', { source, destination, ...options });
+        },
+        tree: async (directory, options) => {
+            return this.fsClient.post('/api/fs/tree', { directory, ...options });
+        },
+        mkdir: async (dirPath, options) => {
+            return this.fsClient.post('/api/fs/mkdir', { path: dirPath, ...options });
+        },
+        exists: async (filePath, basePath) => {
+            const params = new URLSearchParams();
+            params.set('path', filePath);
+            if (basePath) {
+                params.set('basePath', basePath);
+            }
+            return this.fsClient.get(`/api/fs/exists?${params.toString()}`);
+        },
+        stat: async (filePath, basePath) => {
+            const params = new URLSearchParams();
+            params.set('path', filePath);
+            if (basePath) {
+                params.set('basePath', basePath);
+            }
+            return this.fsClient.get(`/api/fs/stat?${params.toString()}`);
+        },
+    };
+    // ==================== Terraform Operations ====================
+    terraform = {
+        init: async (workingDir, options) => {
+            return this.terraformClient.post('/api/terraform/init', { workingDir, ...options });
+        },
+        plan: async (options) => {
+            return this.terraformClient.post('/api/terraform/plan', options);
+        },
+        apply: async (options) => {
+            return this.terraformClient.post('/api/terraform/apply', options);
+        },
+        destroy: async (options) => {
+            return this.terraformClient.post('/api/terraform/destroy', options);
+        },
+        output: async (workingDir, name) => {
+            const params = new URLSearchParams();
+            if (workingDir) {
+                params.set('workingDir', workingDir);
+            }
+            if (name) {
+                params.set('name', name);
+            }
+            const query = params.toString() ? `?${params.toString()}` : '';
+            return this.terraformClient.get(`/api/terraform/output${query}`);
+        },
+        show: async (options) => {
+            const params = new URLSearchParams();
+            if (options?.workingDir) {
+                params.set('workingDir', options.workingDir);
+            }
+            if (options?.planFile) {
+                params.set('planFile', options.planFile);
+            }
+            if (options?.address) {
+                params.set('address', options.address);
+            }
+            const query = params.toString() ? `?${params.toString()}` : '';
+            return this.terraformClient.get(`/api/terraform/show${query}`);
+        },
+        validate: async (workingDir) => {
+            return this.terraformClient.post('/api/terraform/validate', { workingDir });
+        },
+        fmt: async (options) => {
+            return this.terraformClient.post('/api/terraform/fmt', options);
+        },
+        workspace: {
+            list: async (workingDir) => {
+                const params = new URLSearchParams();
+                if (workingDir) {
+                    params.set('workingDir', workingDir);
+                }
+                const query = params.toString() ? `?${params.toString()}` : '';
+                return this.terraformClient.get(`/api/terraform/workspace/list${query}`);
+            },
+            select: async (name, workingDir) => {
+                return this.terraformClient.post('/api/terraform/workspace/select', { name, workingDir });
+            },
+            new: async (name, workingDir) => {
+                return this.terraformClient.post('/api/terraform/workspace/new', { name, workingDir });
+            },
+            delete: async (name, workingDir) => {
+                return this.terraformClient.post('/api/terraform/workspace/delete', { name, workingDir });
+            },
+        },
+        state: {
+            list: async (workingDir) => {
+                const params = new URLSearchParams();
+                if (workingDir) {
+                    params.set('workingDir', workingDir);
+                }
+                const query = params.toString() ? `?${params.toString()}` : '';
+                return this.terraformClient.get(`/api/terraform/state/list${query}`);
+            },
+            show: async (address, workingDir) => {
+                const params = new URLSearchParams();
+                params.set('address', address);
+                if (workingDir) {
+                    params.set('workingDir', workingDir);
+                }
+                return this.terraformClient.get(`/api/terraform/state/show?${params.toString()}`);
+            },
+            mv: async (directory, source, destination) => {
+                return this.terraformClient.post('/api/terraform/state/mv', {
+                    directory,
+                    source,
+                    destination,
+                });
+            },
+            pull: async (directory) => {
+                const params = new URLSearchParams();
+                params.set('directory', directory);
+                return this.terraformClient.get(`/api/terraform/state/pull?${params.toString()}`);
+            },
+            push: async (directory, options) => {
+                return this.terraformClient.post('/api/terraform/state/push', { directory, ...options });
+            },
+        },
+        taint: async (directory, address) => {
+            return this.terraformClient.post('/api/terraform/taint', { directory, address });
+        },
+        untaint: async (directory, address) => {
+            return this.terraformClient.post('/api/terraform/untaint', { directory, address });
+        },
+        graph: async (directory, options) => {
+            const params = new URLSearchParams();
+            params.set('directory', directory);
+            if (options?.type) {
+                params.set('type', options.type);
+            }
+            return this.terraformClient.get(`/api/terraform/graph?${params.toString()}`);
+        },
+        forceUnlock: async (directory, lockId) => {
+            return this.terraformClient.post('/api/terraform/force-unlock', { directory, lockId });
+        },
+        refresh: async (directory, options) => {
+            return this.terraformClient.post('/api/terraform/refresh', { directory, ...options });
+        },
+    };
+    // ==================== Kubernetes Operations ====================
+    k8s = {
+        get: async (resource, options) => {
+            const params = new URLSearchParams();
+            params.set('resource', resource);
+            if (options?.name) {
+                params.set('name', options.name);
+            }
+            if (options?.namespace) {
+                params.set('namespace', options.namespace);
+            }
+            if (options?.selector) {
+                params.set('selector', options.selector);
+            }
+            if (options?.allNamespaces) {
+                params.set('allNamespaces', 'true');
+            }
+            if (options?.output) {
+                params.set('output', options.output);
+            }
+            if (options?.kubeconfig) {
+                params.set('kubeconfig', options.kubeconfig);
+            }
+            if (options?.context) {
+                params.set('context', options.context);
+            }
+            return this.k8sClient.get(`/api/k8s/resources?${params.toString()}`);
+        },
+        apply: async (manifest, options) => {
+            return this.k8sClient.post('/api/k8s/apply', { manifest, ...options });
+        },
+        delete: async (resource, options) => {
+            return this.k8sClient.post('/api/k8s/delete', { resource, ...options });
+        },
+        logs: async (pod, options) => {
+            const params = new URLSearchParams();
+            params.set('pod', pod);
+            if (options?.namespace) {
+                params.set('namespace', options.namespace);
+            }
+            if (options?.container) {
+                params.set('container', options.container);
+            }
+            if (options?.tail) {
+                params.set('tail', options.tail.toString());
+            }
+            if (options?.previous) {
+                params.set('previous', 'true');
+            }
+            if (options?.since) {
+                params.set('since', options.since);
+            }
+            if (options?.timestamps) {
+                params.set('timestamps', 'true');
+            }
+            if (options?.kubeconfig) {
+                params.set('kubeconfig', options.kubeconfig);
+            }
+            if (options?.context) {
+                params.set('context', options.context);
+            }
+            return this.k8sClient.get(`/api/k8s/logs?${params.toString()}`);
+        },
+        exec: async (pod, command, options) => {
+            return this.k8sClient.post('/api/k8s/exec', { pod, command, ...options });
+        },
+        describe: async (resource, options) => {
+            const params = new URLSearchParams();
+            params.set('resource', resource);
+            if (options?.name) {
+                params.set('name', options.name);
+            }
+            if (options?.namespace) {
+                params.set('namespace', options.namespace);
+            }
+            if (options?.selector) {
+                params.set('selector', options.selector);
+            }
+            if (options?.allNamespaces) {
+                params.set('allNamespaces', 'true');
+            }
+            if (options?.kubeconfig) {
+                params.set('kubeconfig', options.kubeconfig);
+            }
+            if (options?.context) {
+                params.set('context', options.context);
+            }
+            return this.k8sClient.get(`/api/k8s/describe?${params.toString()}`);
+        },
+        scale: async (resource, name, replicas, options) => {
+            return this.k8sClient.post('/api/k8s/scale', { resource, name, replicas, ...options });
+        },
+        rollout: async (resource, name, action, options) => {
+            return this.k8sClient.post('/api/k8s/rollout', { resource, name, action, ...options });
+        },
+        contexts: async (kubeconfig) => {
+            const params = new URLSearchParams();
+            if (kubeconfig) {
+                params.set('kubeconfig', kubeconfig);
+            }
+            const query = params.toString() ? `?${params.toString()}` : '';
+            return this.k8sClient.get(`/api/k8s/contexts${query}`);
+        },
+        namespaces: async (kubeconfig, context) => {
+            const params = new URLSearchParams();
+            if (kubeconfig) {
+                params.set('kubeconfig', kubeconfig);
+            }
+            if (context) {
+                params.set('context', context);
+            }
+            const query = params.toString() ? `?${params.toString()}` : '';
+            return this.k8sClient.get(`/api/k8s/namespaces${query}`);
+        },
+        createNamespace: async (name, options) => {
+            return this.k8sClient.post('/api/k8s/namespace', { name, ...options });
+        },
+        deleteNamespace: async (name, options) => {
+            return this.k8sClient.post('/api/k8s/namespace/delete', { name, ...options });
+        },
+        portForward: async (pod, ports, options) => {
+            return this.k8sClient.post('/api/k8s/port-forward', { pod, ports, ...options });
+        },
+        top: async (resourceType, options) => {
+            const params = new URLSearchParams();
+            if (options?.namespace) {
+                params.set('namespace', options.namespace);
+            }
+            if (options?.kubeconfig) {
+                params.set('kubeconfig', options.kubeconfig);
+            }
+            if (options?.context) {
+                params.set('context', options.context);
+            }
+            const query = params.toString() ? `?${params.toString()}` : '';
+            return this.k8sClient.get(`/api/k8s/top/${resourceType}${query}`);
+        },
+        patch: async (resource, name, patch, options) => {
+            return this.k8sClient.post('/api/k8s/patch', { resource, name, patch, ...options });
+        },
+        label: async (resource, name, labels, options) => {
+            return this.k8sClient.post('/api/k8s/label', { resource, name, labels, ...options });
+        },
+        annotate: async (resource, name, annotations, options) => {
+            return this.k8sClient.post('/api/k8s/annotate', { resource, name, annotations, ...options });
+        },
+    };
+    // ==================== Helm Operations ====================
+    helm = {
+        install: async (name, chart, options) => {
+            return this.helmClient.post('/api/helm/install', { name, chart, ...options });
+        },
+        upgrade: async (name, chart, options) => {
+            return this.helmClient.post('/api/helm/upgrade', { name, chart, ...options });
+        },
+        uninstall: async (name, options) => {
+            return this.helmClient.post('/api/helm/uninstall', { name, ...options });
+        },
+        list: async (options) => {
+            const params = new URLSearchParams();
+            if (options?.namespace) {
+                params.set('namespace', options.namespace);
+            }
+            if (options?.allNamespaces) {
+                params.set('allNamespaces', 'true');
+            }
+            if (options?.filter) {
+                params.set('filter', options.filter);
+            }
+            if (options?.maxResults) {
+                params.set('maxResults', options.maxResults.toString());
+            }
+            if (options?.kubeconfig) {
+                params.set('kubeconfig', options.kubeconfig);
+            }
+            if (options?.kubeContext) {
+                params.set('kubeContext', options.kubeContext);
+            }
+            const query = params.toString() ? `?${params.toString()}` : '';
+            return this.helmClient.get(`/api/helm/list${query}`);
+        },
+        rollback: async (name, revision, options) => {
+            return this.helmClient.post('/api/helm/rollback', { name, revision, ...options });
+        },
+        getValues: async (name, options) => {
+            const params = new URLSearchParams();
+            params.set('name', name);
+            if (options?.namespace) {
+                params.set('namespace', options.namespace);
+            }
+            if (options?.allValues) {
+                params.set('allValues', 'true');
+            }
+            if (options?.revision) {
+                params.set('revision', options.revision.toString());
+            }
+            if (options?.kubeconfig) {
+                params.set('kubeconfig', options.kubeconfig);
+            }
+            if (options?.kubeContext) {
+                params.set('kubeContext', options.kubeContext);
+            }
+            return this.helmClient.get(`/api/helm/values?${params.toString()}`);
+        },
+        history: async (name, options) => {
+            const params = new URLSearchParams();
+            params.set('name', name);
+            if (options?.namespace) {
+                params.set('namespace', options.namespace);
+            }
+            if (options?.maxResults) {
+                params.set('maxResults', options.maxResults.toString());
+            }
+            if (options?.kubeconfig) {
+                params.set('kubeconfig', options.kubeconfig);
+            }
+            if (options?.kubeContext) {
+                params.set('kubeContext', options.kubeContext);
+            }
+            return this.helmClient.get(`/api/helm/history?${params.toString()}`);
+        },
+        repo: {
+            add: async (name, url, options) => {
+                return this.helmClient.post('/api/helm/repo', { action: 'add', name, url, ...options });
+            },
+            remove: async (name) => {
+                return this.helmClient.post('/api/helm/repo', { action: 'remove', name });
+            },
+            list: async () => {
+                return this.helmClient.post('/api/helm/repo', { action: 'list' });
+            },
+            update: async () => {
+                return this.helmClient.post('/api/helm/repo', { action: 'update' });
+            },
+        },
+        search: async (keyword, options) => {
+            const params = new URLSearchParams();
+            params.set('keyword', keyword);
+            if (options?.version) {
+                params.set('version', options.version);
+            }
+            if (options?.versions) {
+                params.set('versions', 'true');
+            }
+            if (options?.hub) {
+                params.set('hub', 'true');
+            }
+            if (options?.maxResults) {
+                params.set('maxResults', options.maxResults.toString());
+            }
+            if (options?.kubeconfig) {
+                params.set('kubeconfig', options.kubeconfig);
+            }
+            if (options?.kubeContext) {
+                params.set('kubeContext', options.kubeContext);
+            }
+            return this.helmClient.get(`/api/helm/search?${params.toString()}`);
+        },
+        template: async (name, chart, options) => {
+            return this.helmClient.post('/api/helm/template', { name, chart, ...options });
+        },
+        show: async (chart, options) => {
+            const params = new URLSearchParams();
+            params.set('chart', chart);
+            if (options?.subcommand) {
+                params.set('subcommand', options.subcommand);
+            }
+            if (options?.version) {
+                params.set('version', options.version);
+            }
+            return this.helmClient.get(`/api/helm/show?${params.toString()}`);
+        },
+        lint: async (chartPath, options) => {
+            return this.helmClient.post('/api/helm/lint', { chartPath, ...options });
+        },
+    };
+    // ==================== GitHub Operations ====================
+    github = {
+        /**
+         * Set authorization token for GitHub API requests
+         */
+        setToken: (token) => {
+            this.githubClient = new RestClient(ServiceURLs.GITHUB_TOOLS, {
+                headers: { Authorization: `Bearer ${token}` },
+            });
+        },
+        // Pull Request Operations
+        prs: {
+            list: async (owner, repo, options) => {
+                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', options.perPage.toString());
+                }
+                return this.githubClient.get(`/api/github/prs?${params.toString()}`);
+            },
+            get: async (owner, repo, prNumber) => {
+                const params = new URLSearchParams();
+                params.set('owner', owner);
+                params.set('repo', repo);
+                return this.githubClient.get(`/api/github/prs/${prNumber}?${params.toString()}`);
+            },
+            create: async (owner, repo, params) => {
+                return this.githubClient.post('/api/github/prs', { owner, repo, ...params });
+            },
+            merge: async (owner, repo, prNumber, options) => {
+                return this.githubClient.post(`/api/github/prs/${prNumber}/merge`, {
+                    owner,
+                    repo,
+                    commit_title: options?.commitTitle,
+                    commit_message: options?.commitMessage,
+                    merge_method: options?.mergeMethod,
+                });
+            },
+        },
+        // Issue Operations
+        issues: {
+            list: async (owner, repo, options) => {
+                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', options.perPage.toString());
+                }
+                return this.githubClient.get(`/api/github/issues?${params.toString()}`);
+            },
+            get: async (owner, repo, issueNumber) => {
+                const params = new URLSearchParams();
+                params.set('owner', owner);
+                params.set('repo', repo);
+                return this.githubClient.get(`/api/github/issues/${issueNumber}?${params.toString()}`);
+            },
+            create: async (owner, repo, params) => {
+                return this.githubClient.post('/api/github/issues', { owner, repo, ...params });
+            },
+            close: async (owner, repo, issueNumber) => {
+                const params = new URLSearchParams();
+                params.set('owner', owner);
+                params.set('repo', repo);
+                return this.githubClient.put(`/api/github/issues/${issueNumber}/close?${params.toString()}`, {});
+            },
+            addComment: async (owner, repo, issueNumber, body) => {
+                return this.githubClient.post(`/api/github/issues/${issueNumber}/comments`, {
+                    owner,
+                    repo,
+                    body,
+                });
+            },
+        },
+        // Repository Operations
+        repos: {
+            get: async (owner, repo) => {
+                const params = new URLSearchParams();
+                params.set('owner', owner);
+                params.set('repo', repo);
+                return this.githubClient.get(`/api/github/repos?${params.toString()}`);
+            },
+            listBranches: async (owner, repo, options) => {
+                const params = new URLSearchParams();
+                params.set('owner', owner);
+                params.set('repo', repo);
+                if (options?.perPage) {
+                    params.set('per_page', options.perPage.toString());
+                }
+                return this.githubClient.get(`/api/github/repos/branches?${params.toString()}`);
+            },
+            createBranch: async (owner, repo, branch, sha) => {
+                return this.githubClient.post('/api/github/repos/branches', { owner, repo, branch, sha });
+            },
+            deleteBranch: async (owner, repo, branch) => {
+                const params = new URLSearchParams();
+                params.set('owner', owner);
+                params.set('repo', repo);
+                params.set('branch', branch);
+                return this.githubClient.delete(`/api/github/repos/branches?${params.toString()}`);
+            },
+        },
+        // User Operations
+        user: {
+            get: async () => {
+                return this.githubClient.get('/api/github/user');
+            },
+        },
+    };
+    // ==================== AWS Operations ====================
+    aws = {
+        ec2: {
+            listInstances: async (options) => {
+                const params = new URLSearchParams();
+                if (options?.instanceIds) {
+                    params.set('instanceIds', options.instanceIds.join(','));
+                }
+                if (options?.maxResults) {
+                    params.set('maxResults', options.maxResults.toString());
+                }
+                if (options?.nextToken) {
+                    params.set('nextToken', options.nextToken);
+                }
+                if (options?.region) {
+                    params.set('region', options.region);
+                }
+                const query = params.toString() ? `?${params.toString()}` : '';
+                return this.awsClient.get(`/api/aws/ec2/instances${query}`);
+            },
+            startInstances: async (instanceIds, region) => {
+                return this.awsClient.post('/api/aws/ec2/instances/start', { instanceIds, region });
+            },
+            stopInstances: async (instanceIds, options) => {
+                return this.awsClient.post('/api/aws/ec2/instances/stop', { instanceIds, ...options });
+            },
+            rebootInstances: async (instanceIds, region) => {
+                return this.awsClient.post('/api/aws/ec2/instances/reboot', { instanceIds, region });
+            },
+            terminateInstances: async (instanceIds, region) => {
+                return this.awsClient.post('/api/aws/ec2/instances/terminate', { instanceIds, region });
+            },
+            runInstances: async (imageId, instanceType, options) => {
+                return this.awsClient.post('/api/aws/ec2/instances/run', {
+                    imageId,
+                    instanceType,
+                    ...options,
+                });
+            },
+            listRegions: async (region) => {
+                const query = region ? `?region=${encodeURIComponent(region)}` : '';
+                return this.awsClient.get(`/api/aws/ec2/regions${query}`);
+            },
+            listVpcs: async (region) => {
+                const query = region ? `?region=${encodeURIComponent(region)}` : '';
+                return this.awsClient.get(`/api/aws/ec2/vpcs${query}`);
+            },
+            listSubnets: async (options) => {
+                const params = new URLSearchParams();
+                if (options?.vpcId) {
+                    params.set('vpcId', options.vpcId);
+                }
+                if (options?.region) {
+                    params.set('region', options.region);
+                }
+                const query = params.toString() ? `?${params.toString()}` : '';
+                return this.awsClient.get(`/api/aws/ec2/subnets${query}`);
+            },
+            listSecurityGroups: async (options) => {
+                const params = new URLSearchParams();
+                if (options?.vpcId) {
+                    params.set('vpcId', options.vpcId);
+                }
+                if (options?.region) {
+                    params.set('region', options.region);
+                }
+                const query = params.toString() ? `?${params.toString()}` : '';
+                return this.awsClient.get(`/api/aws/ec2/security-groups${query}`);
+            },
+        },
+        s3: {
+            listBuckets: async (region) => {
+                const query = region ? `?region=${encodeURIComponent(region)}` : '';
+                return this.awsClient.get(`/api/aws/s3/buckets${query}`);
+            },
+            listObjects: async (bucket, options) => {
+                const params = new URLSearchParams();
+                params.set('bucket', bucket);
+                if (options?.prefix) {
+                    params.set('prefix', options.prefix);
+                }
+                if (options?.delimiter) {
+                    params.set('delimiter', options.delimiter);
+                }
+                if (options?.maxKeys) {
+                    params.set('maxKeys', options.maxKeys.toString());
+                }
+                if (options?.continuationToken) {
+                    params.set('continuationToken', options.continuationToken);
+                }
+                if (options?.region) {
+                    params.set('region', options.region);
+                }
+                return this.awsClient.get(`/api/aws/s3/objects?${params.toString()}`);
+            },
+            getObject: async (bucket, key, region) => {
+                const params = new URLSearchParams();
+                params.set('bucket', bucket);
+                params.set('key', key);
+                if (region) {
+                    params.set('region', region);
+                }
+                return this.awsClient.get(`/api/aws/s3/object?${params.toString()}`);
+            },
+            putObject: async (bucket, key, body, options) => {
+                return this.awsClient.post('/api/aws/s3/object', { bucket, key, body, ...options });
+            },
+            deleteObject: async (bucket, key, region) => {
+                const params = new URLSearchParams();
+                params.set('bucket', bucket);
+                params.set('key', key);
+                if (region) {
+                    params.set('region', region);
+                }
+                return this.awsClient.delete(`/api/aws/s3/object?${params.toString()}`);
+            },
+            createBucket: async (bucket, region) => {
+                return this.awsClient.post('/api/aws/s3/bucket', { bucket, region });
+            },
+            deleteBucket: async (bucket, region) => {
+                const params = new URLSearchParams();
+                params.set('bucket', bucket);
+                if (region) {
+                    params.set('region', region);
+                }
+                return this.awsClient.delete(`/api/aws/s3/bucket?${params.toString()}`);
+            },
+        },
+        iam: {
+            listUsers: async (options) => {
+                const params = new URLSearchParams();
+                if (options?.maxItems) {
+                    params.set('maxItems', options.maxItems.toString());
+                }
+                if (options?.marker) {
+                    params.set('marker', options.marker);
+                }
+                if (options?.pathPrefix) {
+                    params.set('pathPrefix', options.pathPrefix);
+                }
+                if (options?.region) {
+                    params.set('region', options.region);
+                }
+                const query = params.toString() ? `?${params.toString()}` : '';
+                return this.awsClient.get(`/api/aws/iam/users${query}`);
+            },
+            getUser: async (userName, region) => {
+                const params = new URLSearchParams();
+                params.set('userName', userName);
+                if (region) {
+                    params.set('region', region);
+                }
+                return this.awsClient.get(`/api/aws/iam/user?${params.toString()}`);
+            },
+            createUser: async (userName, options) => {
+                return this.awsClient.post('/api/aws/iam/user', { userName, ...options });
+            },
+            deleteUser: async (userName, region) => {
+                const params = new URLSearchParams();
+                params.set('userName', userName);
+                if (region) {
+                    params.set('region', region);
+                }
+                return this.awsClient.delete(`/api/aws/iam/user?${params.toString()}`);
+            },
+            listRoles: async (options) => {
+                const params = new URLSearchParams();
+                if (options?.maxItems) {
+                    params.set('maxItems', options.maxItems.toString());
+                }
+                if (options?.marker) {
+                    params.set('marker', options.marker);
+                }
+                if (options?.pathPrefix) {
+                    params.set('pathPrefix', options.pathPrefix);
+                }
+                if (options?.region) {
+                    params.set('region', options.region);
+                }
+                const query = params.toString() ? `?${params.toString()}` : '';
+                return this.awsClient.get(`/api/aws/iam/roles${query}`);
+            },
+            getRole: async (roleName, region) => {
+                const params = new URLSearchParams();
+                params.set('roleName', roleName);
+                if (region) {
+                    params.set('region', region);
+                }
+                return this.awsClient.get(`/api/aws/iam/role?${params.toString()}`);
+            },
+            listPolicies: async (options) => {
+                const params = new URLSearchParams();
+                if (options?.maxItems) {
+                    params.set('maxItems', options.maxItems.toString());
+                }
+                if (options?.marker) {
+                    params.set('marker', options.marker);
+                }
+                if (options?.scope) {
+                    params.set('scope', options.scope);
+                }
+                if (options?.onlyAttached) {
+                    params.set('onlyAttached', 'true');
+                }
+                if (options?.region) {
+                    params.set('region', options.region);
+                }
+                const query = params.toString() ? `?${params.toString()}` : '';
+                return this.awsClient.get(`/api/aws/iam/policies${query}`);
+            },
+            listGroups: async (options) => {
+                const params = new URLSearchParams();
+                if (options?.maxItems) {
+                    params.set('maxItems', options.maxItems.toString());
+                }
+                if (options?.marker) {
+                    params.set('marker', options.marker);
+                }
+                if (options?.pathPrefix) {
+                    params.set('pathPrefix', options.pathPrefix);
+                }
+                if (options?.region) {
+                    params.set('region', options.region);
+                }
+                const query = params.toString() ? `?${params.toString()}` : '';
+                return this.awsClient.get(`/api/aws/iam/groups${query}`);
+            },
+        },
+    };
+    // ==================== GCP Operations ====================
+    gcp = {
+        compute: {
+            listInstances: async (options) => {
+                const params = new URLSearchParams();
+                if (options?.project) {
+                    params.set('project', options.project);
+                }
+                if (options?.zone) {
+                    params.set('zone', options.zone);
+                }
+                if (options?.maxResults) {
+                    params.set('maxResults', options.maxResults.toString());
+                }
+                if (options?.pageToken) {
+                    params.set('pageToken', options.pageToken);
+                }
+                const query = params.toString() ? `?${params.toString()}` : '';
+                return this.gcpClient.get(`/api/gcp/compute/instances${query}`);
+            },
+            startInstance: async (instance, options) => {
+                return this.gcpClient.post('/api/gcp/compute/instances/start', { instance, ...options });
+            },
+            stopInstance: async (instance, options) => {
+                return this.gcpClient.post('/api/gcp/compute/instances/stop', { instance, ...options });
+            },
+        },
+        storage: {
+            listBuckets: async (options) => {
+                const params = new URLSearchParams();
+                if (options?.project) {
+                    params.set('project', options.project);
+                }
+                if (options?.maxResults) {
+                    params.set('maxResults', options.maxResults.toString());
+                }
+                if (options?.pageToken) {
+                    params.set('pageToken', options.pageToken);
+                }
+                const query = params.toString() ? `?${params.toString()}` : '';
+                return this.gcpClient.get(`/api/gcp/storage/buckets${query}`);
+            },
+        },
+        gke: {
+            listClusters: async (options) => {
+                const params = new URLSearchParams();
+                if (options?.project) {
+                    params.set('project', options.project);
+                }
+                if (options?.zone) {
+                    params.set('zone', options.zone);
+                }
+                const query = params.toString() ? `?${params.toString()}` : '';
+                return this.gcpClient.get(`/api/gcp/gke/clusters${query}`);
+            },
+        },
+        iam: {
+            listServiceAccounts: async (options) => {
+                const params = new URLSearchParams();
+                if (options?.project) {
+                    params.set('project', options.project);
+                }
+                if (options?.maxResults) {
+                    params.set('maxResults', options.maxResults.toString());
+                }
+                if (options?.pageToken) {
+                    params.set('pageToken', options.pageToken);
+                }
+                const query = params.toString() ? `?${params.toString()}` : '';
+                return this.gcpClient.get(`/api/gcp/iam/service-accounts${query}`);
+            },
+            listRoles: async (options) => {
+                const params = new URLSearchParams();
+                if (options?.project) {
+                    params.set('project', options.project);
+                }
+                if (options?.maxResults) {
+                    params.set('maxResults', options.maxResults.toString());
+                }
+                if (options?.pageToken) {
+                    params.set('pageToken', options.pageToken);
+                }
+                const query = params.toString() ? `?${params.toString()}` : '';
+                return this.gcpClient.get(`/api/gcp/iam/roles${query}`);
+            },
+        },
+        discover: {
+            startDiscovery: async (options) => {
+                return this.gcpClient.post('/api/gcp/discover/start', options);
+            },
+            getSession: async (sessionId) => {
+                return this.gcpClient.get(`/api/gcp/discover/session/${sessionId}`);
+            },
+        },
+        terraform: {
+            generate: async (options) => {
+                return this.gcpClient.post('/api/gcp/terraform/generate', options);
+            },
+        },
+    };
+    // ==================== Azure Operations ====================
+    azure = {
+        compute: {
+            listVMs: async (options) => {
+                const params = new URLSearchParams();
+                if (options?.subscriptionId) {
+                    params.set('subscriptionId', options.subscriptionId);
+                }
+                if (options?.resourceGroup) {
+                    params.set('resourceGroup', options.resourceGroup);
+                }
+                if (options?.maxResults) {
+                    params.set('maxResults', options.maxResults.toString());
+                }
+                const query = params.toString() ? `?${params.toString()}` : '';
+                return this.azureClient.get(`/api/azure/compute/vms${query}`);
+            },
+            startVM: async (vmName, options) => {
+                return this.azureClient.post('/api/azure/compute/vms/start', { vmName, ...options });
+            },
+            stopVM: async (vmName, options) => {
+                return this.azureClient.post('/api/azure/compute/vms/stop', { vmName, ...options });
+            },
+        },
+        storage: {
+            listAccounts: async (options) => {
+                const params = new URLSearchParams();
+                if (options?.subscriptionId) {
+                    params.set('subscriptionId', options.subscriptionId);
+                }
+                if (options?.resourceGroup) {
+                    params.set('resourceGroup', options.resourceGroup);
+                }
+                const query = params.toString() ? `?${params.toString()}` : '';
+                return this.azureClient.get(`/api/azure/storage/accounts${query}`);
+            },
+        },
+        aks: {
+            listClusters: async (options) => {
+                const params = new URLSearchParams();
+                if (options?.subscriptionId) {
+                    params.set('subscriptionId', options.subscriptionId);
+                }
+                if (options?.resourceGroup) {
+                    params.set('resourceGroup', options.resourceGroup);
+                }
+                const query = params.toString() ? `?${params.toString()}` : '';
+                return this.azureClient.get(`/api/azure/aks/clusters${query}`);
+            },
+        },
+        iam: {
+            listRoleAssignments: async (options) => {
+                const params = new URLSearchParams();
+                if (options?.subscriptionId) {
+                    params.set('subscriptionId', options.subscriptionId);
+                }
+                if (options?.resourceGroup) {
+                    params.set('resourceGroup', options.resourceGroup);
+                }
+                if (options?.scope) {
+                    params.set('scope', options.scope);
+                }
+                const query = params.toString() ? `?${params.toString()}` : '';
+                return this.azureClient.get(`/api/azure/iam/role-assignments${query}`);
+            },
+        },
+        discover: {
+            startDiscovery: async (options) => {
+                return this.azureClient.post('/api/azure/discover/start', options);
+            },
+            getSession: async (sessionId) => {
+                return this.azureClient.get(`/api/azure/discover/session/${sessionId}`);
+            },
+        },
+        terraform: {
+            generate: async (options) => {
+                return this.azureClient.post('/api/azure/terraform/generate', options);
+            },
+        },
+    };
+    // ==================== Health Checks ====================
+    /**
+     * Check health of all tool services
+     */
+    async healthCheck() {
+        const [git, fs, terraform, k8s, helm, aws, github, gcp, azure] = await Promise.all([
+            this.gitClient.healthCheck(),
+            this.fsClient.healthCheck(),
+            this.terraformClient.healthCheck(),
+            this.k8sClient.healthCheck(),
+            this.helmClient.healthCheck(),
+            this.awsClient.healthCheck(),
+            this.githubClient.healthCheck(),
+            this.gcpClient.healthCheck(),
+            this.azureClient.healthCheck(),
+        ]);
+        return { git, fs, terraform, k8s, helm, aws, github, gcp, azure };
+    }
+    /**
+     * Check health of a specific service
+     */
+    async healthCheckService(service) {
+        const clients = {
+            git: this.gitClient,
+            fs: this.fsClient,
+            terraform: this.terraformClient,
+            k8s: this.k8sClient,
+            helm: this.helmClient,
+            aws: this.awsClient,
+            github: this.githubClient,
+            gcp: this.gcpClient,
+            azure: this.azureClient,
+        };
+        return clients[service].healthCheck();
+    }
+}