kynjal-cli 4.0.0 → 4.0.1

package/dist/src/mcp-tools/github-tools.js

@@ -8,48 +8,12 @@
  * - Data is stored locally for workflow coordination
  * - For real GitHub operations, use `gh` CLI or GitHub MCP server
  */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 // Storage paths
-var STORAGE_DIR = '.claude-flow';
-var GITHUB_DIR = 'github';
-var GITHUB_FILE = 'store.json';
+const STORAGE_DIR = '.claude-flow';
+const GITHUB_DIR = 'github';
+const GITHUB_FILE = 'store.json';
 function getGitHubDir() {
     return join(process.cwd(), STORAGE_DIR, GITHUB_DIR);
 }
@@ -57,19 +21,19 @@ function getGitHubPath() {
     return join(getGitHubDir(), GITHUB_FILE);
 }
 function ensureGitHubDir() {
-    var dir = getGitHubDir();
+    const dir = getGitHubDir();
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }
 }
 function loadGitHubStore() {
     try {
-        var path = getGitHubPath();
+        const path = getGitHubPath();
         if (existsSync(path)) {
             return JSON.parse(readFileSync(path, 'utf-8'));
         }
     }
-    catch (_a) {
+    catch {
         // Return empty store
     }
     return { repos: {}, prs: {}, issues: {}, version: '3.0.0' };
@@ -78,7 +42,7 @@ function saveGitHubStore(store) {
     ensureGitHubDir();
     writeFileSync(getGitHubPath(), JSON.stringify(store, null, 2), 'utf-8');
 }
-export var githubTools = [
+export const githubTools = [
     {
         name: 'github_repo_analyze',
         description: 'Analyze a GitHub repository',
@@ -89,49 +53,46 @@ export var githubTools = [
                 owner: { type: 'string', description: 'Repository owner' },
                 repo: { type: 'string', description: 'Repository name' },
                 branch: { type: 'string', description: 'Branch to analyze' },
-                deep: { type: 'boolean', description: 'Deep analysis' }
-            }
+                deep: { type: 'boolean', description: 'Deep analysis' },
+            },
+        },
+        handler: async (input) => {
+            const store = loadGitHubStore();
+            const owner = input.owner || 'owner';
+            const repo = input.repo || 'repo';
+            const branch = input.branch || 'main';
+            const repoKey = `${owner}/${repo}`;
+            const repoInfo = {
+                owner,
+                name: repo,
+                branch,
+                lastAnalyzed: new Date().toISOString(),
+                metrics: {
+                    commits: Math.floor(Math.random() * 1000) + 100,
+                    branches: Math.floor(Math.random() * 20) + 1,
+                    contributors: Math.floor(Math.random() * 50) + 1,
+                    openIssues: Math.floor(Math.random() * 30),
+                    openPRs: Math.floor(Math.random() * 10),
+                },
+            };
+            store.repos[repoKey] = repoInfo;
+            saveGitHubStore(store);
+            return {
+                success: true,
+                repository: repoKey,
+                branch,
+                metrics: repoInfo.metrics,
+                analysis: {
+                    languages: ['TypeScript', 'JavaScript', 'JSON'],
+                    mainLanguage: 'TypeScript',
+                    codeQuality: 'A',
+                    testCoverage: `${Math.floor(Math.random() * 30) + 70}%`,
+                    dependencies: Math.floor(Math.random() * 50) + 20,
+                    securityIssues: Math.floor(Math.random() * 3),
+                },
+                lastAnalyzed: repoInfo.lastAnalyzed,
+            };
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var store, owner, repo, branch, repoKey, repoInfo;
-            return __generator(this, function (_a) {
-                store = loadGitHubStore();
-                owner = input.owner || 'owner';
-                repo = input.repo || 'repo';
-                branch = input.branch || 'main';
-                repoKey = owner + "/" + repo;
-                repoInfo = {
-                    owner: owner,
-                    name: repo,
-                    branch: branch,
-                    lastAnalyzed: new Date().toISOString(),
-                    metrics: {
-                        commits: Math.floor(Math.random() * 1000) + 100,
-                        branches: Math.floor(Math.random() * 20) + 1,
-                        contributors: Math.floor(Math.random() * 50) + 1,
-                        openIssues: Math.floor(Math.random() * 30),
-                        openPRs: Math.floor(Math.random() * 10)
-                    }
-                };
-                store.repos[repoKey] = repoInfo;
-                saveGitHubStore(store);
-                return [2 /*return*/, {
-                        success: true,
-                        repository: repoKey,
-                        branch: branch,
-                        metrics: repoInfo.metrics,
-                        analysis: {
-                            languages: ['TypeScript', 'JavaScript', 'JSON'],
-                            mainLanguage: 'TypeScript',
-                            codeQuality: 'A',
-                            testCoverage: Math.floor(Math.random() * 30) + 70 + "%",
-                            dependencies: Math.floor(Math.random() * 50) + 20,
-                            securityIssues: Math.floor(Math.random() * 3)
-                        },
-                        lastAnalyzed: repoInfo.lastAnalyzed
-                    }];
-            });
-        }); }
     },
     {
         name: 'github_pr_manage',
@@ -140,94 +101,91 @@ export var githubTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                action: { type: 'string', "enum": ['list', 'create', 'review', 'merge', 'close'], description: 'Action to perform' },
+                action: { type: 'string', enum: ['list', 'create', 'review', 'merge', 'close'], description: 'Action to perform' },
                 owner: { type: 'string', description: 'Repository owner' },
                 repo: { type: 'string', description: 'Repository name' },
                 prNumber: { type: 'number', description: 'PR number' },
                 title: { type: 'string', description: 'PR title' },
                 branch: { type: 'string', description: 'Source branch' },
                 baseBranch: { type: 'string', description: 'Target branch' },
-                body: { type: 'string', description: 'PR description' }
-            }
+                body: { type: 'string', description: 'PR description' },
+            },
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var store, action, owner, repo, prs, prId, pr, prNumber_1, prKey, prNumber_2, prKey;
-            return __generator(this, function (_a) {
-                store = loadGitHubStore();
-                action = input.action || 'list';
-                owner = input.owner || 'owner';
-                repo = input.repo || 'repo';
-                if (action === 'list') {
-                    prs = Object.values(store.prs);
-                    return [2 /*return*/, {
-                            success: true,
-                            pullRequests: prs,
-                            total: prs.length,
-                            open: prs.filter(function (pr) { return pr.status === 'open'; }).length
-                        }];
-                }
-                if (action === 'create') {
-                    prId = "pr-" + Date.now();
-                    pr = {
-                        id: prId,
-                        title: input.title || 'New PR',
-                        status: 'open',
-                        branch: input.branch || 'feature',
-                        baseBranch: input.baseBranch || 'main',
-                        createdAt: new Date().toISOString()
-                    };
-                    store.prs[prId] = pr;
+        handler: async (input) => {
+            const store = loadGitHubStore();
+            const action = input.action || 'list';
+            const owner = input.owner || 'owner';
+            const repo = input.repo || 'repo';
+            if (action === 'list') {
+                const prs = Object.values(store.prs);
+                return {
+                    success: true,
+                    pullRequests: prs,
+                    total: prs.length,
+                    open: prs.filter(pr => pr.status === 'open').length,
+                };
+            }
+            if (action === 'create') {
+                const prId = `pr-${Date.now()}`;
+                const pr = {
+                    id: prId,
+                    title: input.title || 'New PR',
+                    status: 'open',
+                    branch: input.branch || 'feature',
+                    baseBranch: input.baseBranch || 'main',
+                    createdAt: new Date().toISOString(),
+                };
+                store.prs[prId] = pr;
+                saveGitHubStore(store);
+                return {
+                    success: true,
+                    action: 'created',
+                    pullRequest: pr,
+                    url: `https://github.com/${owner}/${repo}/pull/${prId}`,
+                };
+            }
+            if (action === 'review') {
+                return {
+                    success: true,
+                    action: 'reviewed',
+                    prNumber: input.prNumber,
+                    review: {
+                        status: 'approved',
+                        comments: [],
+                        suggestion: 'LGTM',
+                    },
+                };
+            }
+            if (action === 'merge') {
+                const prNumber = input.prNumber;
+                const prKey = Object.keys(store.prs).find(k => k.includes(String(prNumber)));
+                if (prKey && store.prs[prKey]) {
+                    store.prs[prKey].status = 'merged';
                     saveGitHubStore(store);
-                    return [2 /*return*/, {
-                            success: true,
-                            action: 'created',
-                            pullRequest: pr,
-                            url: "https://github.com/" + owner + "/" + repo + "/pull/" + prId
-                        }];
-                }
-                if (action === 'review') {
-                    return [2 /*return*/, {
-                            success: true,
-                            action: 'reviewed',
-                            prNumber: input.prNumber,
-                            review: {
-                                status: 'approved',
-                                comments: [],
-                                suggestion: 'LGTM'
-                            }
-                        }];
-                }
-                if (action === 'merge') {
-                    prNumber_1 = input.prNumber;
-                    prKey = Object.keys(store.prs).find(function (k) { return k.includes(String(prNumber_1)); });
-                    if (prKey && store.prs[prKey]) {
-                        store.prs[prKey].status = 'merged';
-                        saveGitHubStore(store);
-                    }
-                    return [2 /*return*/, {
-                            success: true,
-                            action: 'merged',
-                            prNumber: prNumber_1,
-                            mergedAt: new Date().toISOString()
-                        }];
                 }
-                if (action === 'close') {
-                    prNumber_2 = input.prNumber;
-                    prKey = Object.keys(store.prs).find(function (k) { return k.includes(String(prNumber_2)); });
-                    if (prKey && store.prs[prKey]) {
-                        store.prs[prKey].status = 'closed';
-                        saveGitHubStore(store);
-                    }
-                    return [2 /*return*/, {
-                            success: true,
-                            action: 'closed',
-                            prNumber: prNumber_2,
-                            closedAt: new Date().toISOString()
-                        }];
+                return {
+                    success: true,
+                    action: 'merged',
+                    prNumber,
+                    mergedAt: new Date().toISOString(),
+                };
+            }
+            if (action === 'close') {
+                const prNumber = input.prNumber;
+                const prKey = Object.keys(store.prs).find(k => k.includes(String(prNumber)));
+                if (prKey && store.prs[prKey]) {
+                    store.prs[prKey].status = 'closed';
+                    saveGitHubStore(store);
                 }
-                return [2 /*return*/, { success: false, error: 'Unknown action' }];
-            });
-        }); }
+                return {
+                    success: true,
+                    action: 'closed',
+                    prNumber,
+                    closedAt: new Date().toISOString(),
+                };
+            }
+            return { success: false, error: 'Unknown action' };
+        },
     },
     {
         name: 'github_issue_track',
@@ -236,80 +194,77 @@ export var githubTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                action: { type: 'string', "enum": ['list', 'create', 'update', 'close', 'assign'], description: 'Action to perform' },
+                action: { type: 'string', enum: ['list', 'create', 'update', 'close', 'assign'], description: 'Action to perform' },
                 owner: { type: 'string', description: 'Repository owner' },
                 repo: { type: 'string', description: 'Repository name' },
                 issueNumber: { type: 'number', description: 'Issue number' },
                 title: { type: 'string', description: 'Issue title' },
                 body: { type: 'string', description: 'Issue body' },
                 labels: { type: 'array', items: { type: 'string' }, description: 'Issue labels' },
-                assignees: { type: 'array', items: { type: 'string' }, description: 'Assignees' }
-            }
+                assignees: { type: 'array', items: { type: 'string' }, description: 'Assignees' },
+            },
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var store, action, issues, issueId, issue, issueNumber_1, issueKey, issueNumber_2, issueKey;
-            return __generator(this, function (_a) {
-                store = loadGitHubStore();
-                action = input.action || 'list';
-                if (action === 'list') {
-                    issues = Object.values(store.issues);
-                    return [2 /*return*/, {
-                            success: true,
-                            issues: issues,
-                            total: issues.length,
-                            open: issues.filter(function (i) { return i.status === 'open'; }).length
-                        }];
-                }
-                if (action === 'create') {
-                    issueId = "issue-" + Date.now();
-                    issue = {
-                        id: issueId,
-                        title: input.title || 'New Issue',
-                        status: 'open',
-                        labels: input.labels || [],
-                        createdAt: new Date().toISOString()
-                    };
-                    store.issues[issueId] = issue;
+        handler: async (input) => {
+            const store = loadGitHubStore();
+            const action = input.action || 'list';
+            if (action === 'list') {
+                const issues = Object.values(store.issues);
+                return {
+                    success: true,
+                    issues,
+                    total: issues.length,
+                    open: issues.filter(i => i.status === 'open').length,
+                };
+            }
+            if (action === 'create') {
+                const issueId = `issue-${Date.now()}`;
+                const issue = {
+                    id: issueId,
+                    title: input.title || 'New Issue',
+                    status: 'open',
+                    labels: input.labels || [],
+                    createdAt: new Date().toISOString(),
+                };
+                store.issues[issueId] = issue;
+                saveGitHubStore(store);
+                return {
+                    success: true,
+                    action: 'created',
+                    issue,
+                };
+            }
+            if (action === 'update') {
+                const issueNumber = input.issueNumber;
+                const issueKey = Object.keys(store.issues).find(k => k.includes(String(issueNumber)));
+                if (issueKey && store.issues[issueKey]) {
+                    if (input.title)
+                        store.issues[issueKey].title = input.title;
+                    if (input.labels)
+                        store.issues[issueKey].labels = input.labels;
                     saveGitHubStore(store);
-                    return [2 /*return*/, {
-                            success: true,
-                            action: 'created',
-                            issue: issue
-                        }];
                 }
-                if (action === 'update') {
-                    issueNumber_1 = input.issueNumber;
-                    issueKey = Object.keys(store.issues).find(function (k) { return k.includes(String(issueNumber_1)); });
-                    if (issueKey && store.issues[issueKey]) {
-                        if (input.title)
-                            store.issues[issueKey].title = input.title;
-                        if (input.labels)
-                            store.issues[issueKey].labels = input.labels;
-                        saveGitHubStore(store);
-                    }
-                    return [2 /*return*/, {
-                            success: true,
-                            action: 'updated',
-                            issueNumber: issueNumber_1
-                        }];
-                }
-                if (action === 'close') {
-                    issueNumber_2 = input.issueNumber;
-                    issueKey = Object.keys(store.issues).find(function (k) { return k.includes(String(issueNumber_2)); });
-                    if (issueKey && store.issues[issueKey]) {
-                        store.issues[issueKey].status = 'closed';
-                        saveGitHubStore(store);
-                    }
-                    return [2 /*return*/, {
-                            success: true,
-                            action: 'closed',
-                            issueNumber: issueNumber_2,
-                            closedAt: new Date().toISOString()
-                        }];
+                return {
+                    success: true,
+                    action: 'updated',
+                    issueNumber,
+                };
+            }
+            if (action === 'close') {
+                const issueNumber = input.issueNumber;
+                const issueKey = Object.keys(store.issues).find(k => k.includes(String(issueNumber)));
+                if (issueKey && store.issues[issueKey]) {
+                    store.issues[issueKey].status = 'closed';
+                    saveGitHubStore(store);
                 }
-                return [2 /*return*/, { success: false, error: 'Unknown action' }];
-            });
-        }); }
+                return {
+                    success: true,
+                    action: 'closed',
+                    issueNumber,
+                    closedAt: new Date().toISOString(),
+                };
+            }
+            return { success: false, error: 'Unknown action' };
+        },
     },
     {
         name: 'github_workflow',
@@ -318,57 +273,54 @@ export var githubTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                action: { type: 'string', "enum": ['list', 'trigger', 'status', 'cancel'], description: 'Action to perform' },
+                action: { type: 'string', enum: ['list', 'trigger', 'status', 'cancel'], description: 'Action to perform' },
                 owner: { type: 'string', description: 'Repository owner' },
                 repo: { type: 'string', description: 'Repository name' },
                 workflowId: { type: 'string', description: 'Workflow ID or name' },
-                ref: { type: 'string', description: 'Branch or tag ref' }
+                ref: { type: 'string', description: 'Branch or tag ref' },
+            },
+        },
+        handler: async (input) => {
+            const action = input.action || 'list';
+            if (action === 'list') {
+                return {
+                    success: true,
+                    workflows: [
+                        { id: 'ci.yml', name: 'CI', status: 'active', lastRun: new Date().toISOString() },
+                        { id: 'release.yml', name: 'Release', status: 'active', lastRun: new Date().toISOString() },
+                        { id: 'test.yml', name: 'Tests', status: 'active', lastRun: new Date().toISOString() },
+                    ],
+                };
+            }
+            if (action === 'trigger') {
+                return {
+                    success: true,
+                    action: 'triggered',
+                    workflowId: input.workflowId,
+                    ref: input.ref || 'main',
+                    runId: `run-${Date.now()}`,
+                    triggeredAt: new Date().toISOString(),
+                };
             }
+            if (action === 'status') {
+                return {
+                    success: true,
+                    workflowId: input.workflowId,
+                    status: 'completed',
+                    conclusion: 'success',
+                    duration: '2m 35s',
+                };
+            }
+            if (action === 'cancel') {
+                return {
+                    success: true,
+                    action: 'cancelled',
+                    workflowId: input.workflowId,
+                    cancelledAt: new Date().toISOString(),
+                };
+            }
+            return { success: false, error: 'Unknown action' };
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var action;
-            return __generator(this, function (_a) {
-                action = input.action || 'list';
-                if (action === 'list') {
-                    return [2 /*return*/, {
-                            success: true,
-                            workflows: [
-                                { id: 'ci.yml', name: 'CI', status: 'active', lastRun: new Date().toISOString() },
-                                { id: 'release.yml', name: 'Release', status: 'active', lastRun: new Date().toISOString() },
-                                { id: 'test.yml', name: 'Tests', status: 'active', lastRun: new Date().toISOString() },
-                            ]
-                        }];
-                }
-                if (action === 'trigger') {
-                    return [2 /*return*/, {
-                            success: true,
-                            action: 'triggered',
-                            workflowId: input.workflowId,
-                            ref: input.ref || 'main',
-                            runId: "run-" + Date.now(),
-                            triggeredAt: new Date().toISOString()
-                        }];
-                }
-                if (action === 'status') {
-                    return [2 /*return*/, {
-                            success: true,
-                            workflowId: input.workflowId,
-                            status: 'completed',
-                            conclusion: 'success',
-                            duration: '2m 35s'
-                        }];
-                }
-                if (action === 'cancel') {
-                    return [2 /*return*/, {
-                            success: true,
-                            action: 'cancelled',
-                            workflowId: input.workflowId,
-                            cancelledAt: new Date().toISOString()
-                        }];
-                }
-                return [2 /*return*/, { success: false, error: 'Unknown action' }];
-            });
-        }); }
     },
     {
         name: 'github_metrics',
@@ -379,46 +331,43 @@ export var githubTools = [
             properties: {
                 owner: { type: 'string', description: 'Repository owner' },
                 repo: { type: 'string', description: 'Repository name' },
-                metric: { type: 'string', "enum": ['all', 'commits', 'contributors', 'traffic', 'releases'], description: 'Metric type' },
-                timeRange: { type: 'string', description: 'Time range' }
+                metric: { type: 'string', enum: ['all', 'commits', 'contributors', 'traffic', 'releases'], description: 'Metric type' },
+                timeRange: { type: 'string', description: 'Time range' },
+            },
+        },
+        handler: async (input) => {
+            const metric = input.metric || 'all';
+            const metrics = {
+                commits: {
+                    total: Math.floor(Math.random() * 1000) + 500,
+                    lastWeek: Math.floor(Math.random() * 50) + 10,
+                    lastMonth: Math.floor(Math.random() * 200) + 50,
+                },
+                contributors: {
+                    total: Math.floor(Math.random() * 50) + 5,
+                    active: Math.floor(Math.random() * 20) + 3,
+                    new: Math.floor(Math.random() * 5),
+                },
+                traffic: {
+                    views: Math.floor(Math.random() * 5000) + 1000,
+                    uniqueVisitors: Math.floor(Math.random() * 1000) + 200,
+                    clones: Math.floor(Math.random() * 500) + 50,
+                },
+                releases: {
+                    total: Math.floor(Math.random() * 20) + 5,
+                    latest: '3.0.0-alpha.86',
+                    downloads: Math.floor(Math.random() * 10000) + 1000,
+                },
+            };
+            if (metric === 'all') {
+                return { success: true, metrics };
             }
+            return {
+                success: true,
+                metric,
+                data: metrics[metric],
+            };
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var metric, metrics;
-            return __generator(this, function (_a) {
-                metric = input.metric || 'all';
-                metrics = {
-                    commits: {
-                        total: Math.floor(Math.random() * 1000) + 500,
-                        lastWeek: Math.floor(Math.random() * 50) + 10,
-                        lastMonth: Math.floor(Math.random() * 200) + 50
-                    },
-                    contributors: {
-                        total: Math.floor(Math.random() * 50) + 5,
-                        active: Math.floor(Math.random() * 20) + 3,
-                        "new": Math.floor(Math.random() * 5)
-                    },
-                    traffic: {
-                        views: Math.floor(Math.random() * 5000) + 1000,
-                        uniqueVisitors: Math.floor(Math.random() * 1000) + 200,
-                        clones: Math.floor(Math.random() * 500) + 50
-                    },
-                    releases: {
-                        total: Math.floor(Math.random() * 20) + 5,
-                        latest: '3.0.0-alpha.86',
-                        downloads: Math.floor(Math.random() * 10000) + 1000
-                    }
-                };
-                if (metric === 'all') {
-                    return [2 /*return*/, { success: true, metrics: metrics }];
-                }
-                return [2 /*return*/, {
-                        success: true,
-                        metric: metric,
-                        data: metrics[metric]
-                    }];
-            });
-        }); }
     },
 ];
 //# sourceMappingURL=github-tools.js.map