kynjal-cli 3.1.3 → 4.0.0

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

@@ -8,12 +8,48 @@
  * - 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
-const STORAGE_DIR = '.claude-flow';
-const GITHUB_DIR = 'github';
-const GITHUB_FILE = 'store.json';
+var STORAGE_DIR = '.claude-flow';
+var GITHUB_DIR = 'github';
+var GITHUB_FILE = 'store.json';
 function getGitHubDir() {
     return join(process.cwd(), STORAGE_DIR, GITHUB_DIR);
 }
@@ -21,19 +57,19 @@ function getGitHubPath() {
     return join(getGitHubDir(), GITHUB_FILE);
 }
 function ensureGitHubDir() {
-    const dir = getGitHubDir();
+    var dir = getGitHubDir();
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }
 }
 function loadGitHubStore() {
     try {
-        const path = getGitHubPath();
+        var path = getGitHubPath();
         if (existsSync(path)) {
             return JSON.parse(readFileSync(path, 'utf-8'));
         }
     }
-    catch {
+    catch (_a) {
         // Return empty store
     }
     return { repos: {}, prs: {}, issues: {}, version: '3.0.0' };
@@ -42,7 +78,7 @@ function saveGitHubStore(store) {
     ensureGitHubDir();
     writeFileSync(getGitHubPath(), JSON.stringify(store, null, 2), 'utf-8');
 }
-export const githubTools = [
+export var githubTools = [
     {
         name: 'github_repo_analyze',
         description: 'Analyze a GitHub repository',
@@ -53,46 +89,49 @@ export const 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' },
-            },
-        },
-        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,
-            };
+                deep: { type: 'boolean', description: 'Deep analysis' }
+            }
         },
+        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',
@@ -101,91 +140,94 @@ export const 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' },
-            },
-        },
-        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',
-                    },
-                };
+                body: { type: 'string', description: 'PR description' }
             }
-            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);
+        },
+        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
+                        }];
                 }
-                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';
+                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;
                     saveGitHubStore(store);
+                    return [2 /*return*/, {
+                            success: true,
+                            action: 'created',
+                            pullRequest: pr,
+                            url: "https://github.com/" + owner + "/" + repo + "/pull/" + prId
+                        }];
                 }
-                return {
-                    success: true,
-                    action: 'closed',
-                    prNumber,
-                    closedAt: new Date().toISOString(),
-                };
-            }
-            return { success: false, error: 'Unknown action' };
-        },
+                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 [2 /*return*/, { success: false, error: 'Unknown action' }];
+            });
+        }); }
     },
     {
         name: 'github_issue_track',
@@ -194,77 +236,80 @@ export const 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', description: 'Issue labels' },
-                assignees: { type: 'array', description: 'Assignees' },
-            },
-        },
-        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,
-                };
+                labels: { type: 'array', items: { type: 'string' }, description: 'Issue labels' },
+                assignees: { type: 'array', items: { type: 'string' }, description: 'Assignees' }
             }
-            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);
+        },
+        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
+                        }];
                 }
-                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';
+                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;
                     saveGitHubStore(store);
+                    return [2 /*return*/, {
+                            success: true,
+                            action: 'created',
+                            issue: issue
+                        }];
                 }
-                return {
-                    success: true,
-                    action: 'closed',
-                    issueNumber,
-                    closedAt: new Date().toISOString(),
-                };
-            }
-            return { success: false, error: 'Unknown action' };
-        },
+                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 [2 /*return*/, { success: false, error: 'Unknown action' }];
+            });
+        }); }
     },
     {
         name: 'github_workflow',
@@ -273,54 +318,57 @@ export const 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' },
-            },
-        },
-        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(),
-                };
+                ref: { type: 'string', description: 'Branch or tag ref' }
             }
-            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',
@@ -331,43 +379,46 @@ export const 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' },
-            },
-        },
-        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 };
+                metric: { type: 'string', "enum": ['all', 'commits', 'contributors', 'traffic', 'releases'], description: 'Metric type' },
+                timeRange: { type: 'string', description: 'Time range' }
             }
-            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