gitpadi 2.0.1 → 2.0.3

package/src/commands/contribute.ts

@@ -0,0 +1,354 @@
+// commands/contribute.ts — Contributor workflow for GitPadi
+
+import chalk from 'chalk';
+import ora from 'ora';
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import boxen from 'boxen';
+import {
+    getOctokit,
+    getOwner,
+    getRepo,
+    forkRepo,
+    getAuthenticatedUser,
+    getLatestCheckRuns,
+    setRepo
+} from '../core/github.js';
+
+const dim = chalk.dim;
+const yellow = chalk.yellow;
+const green = chalk.green;
+const cyan = chalk.cyan;
+const white = chalk.white;
+
+/**
+ * Parses a GitHub Issue/Repo URL or "owner/repo" string
+ */
+function parseTarget(input: string): { owner: string, repo: string, issue?: number } {
+    const urlPattern = /github\.com\/([^/]+)\/([^/]+)(\/issues\/(\d+))?/;
+    const match = input.match(urlPattern);
+
+    if (match) {
+        return {
+            owner: match[1],
+            repo: match[2],
+            issue: match[4] ? parseInt(match[4]) : undefined
+        };
+    }
+
+    const parts = input.split('/');
+    if (parts.length === 2) {
+        return { owner: parts[0], repo: parts[1] };
+    }
+
+    throw new Error('Invalid target. Use a GitHub URL or "owner/repo" format.');
+}
+
+/**
+ * Phase 2: Fork & Clone Workflow (The "Start" Command)
+ */
+export async function forkAndClone(target: string) {
+    const { owner, repo, issue } = parseTarget(target);
+
+    // 1. Fork first (idempotent — GitHub returns existing fork if it exists)
+    const spinner = ora(`Forking ${cyan(`${owner}/${repo}`)}...`).start();
+    let myUser: string;
+
+    try {
+        myUser = await getAuthenticatedUser();
+        const forkFullName = await forkRepo(owner, repo);
+        spinner.succeed(`Forked to ${green(forkFullName)}`);
+    } catch (e: any) {
+        spinner.fail(e.message);
+        return;
+    }
+
+    // 2. Ask where to clone
+    const inquirer = (await import('inquirer')).default;
+    const path = (await import('path')).default;
+    const os = (await import('os')).default;
+
+    const { parentDir } = await inquirer.prompt([{
+        type: 'input',
+        name: 'parentDir',
+        message: cyan('📂 Where to clone? (parent directory):'),
+        default: '.',
+    }]);
+
+    // Resolve ~ and build full path: parentDir/repoName
+    const resolvedParent = parentDir.startsWith('~')
+        ? parentDir.replace('~', os.homedir())
+        : parentDir;
+    let cloneDir: string = path.resolve(resolvedParent, repo);
+
+    // 3. Handle existing directory
+    if (fs.existsSync(cloneDir)) {
+        // Check if it's already a valid git clone of this repo
+        let isValidClone = false;
+        try {
+            const remoteUrl = execSync('git remote get-url origin', { cwd: cloneDir, encoding: 'utf-8', stdio: 'pipe' }).trim();
+            if (remoteUrl.includes(repo)) isValidClone = true;
+        } catch { /* not a git repo */ }
+
+        if (isValidClone) {
+            console.log(yellow(`\n  📂 "${cloneDir}" already contains a clone of ${repo}.`));
+            console.log(dim('  Syncing with upstream...\n'));
+
+            process.chdir(cloneDir);
+            setRepo(owner, repo);
+
+            // Ensure upstream remote exists
+            try { execSync(`git remote add upstream https://github.com/${owner}/${repo}.git`, { stdio: 'pipe' }); } catch { /* exists */ }
+
+            // 1. Detect default branch
+            let defaultBranch = 'main';
+            try {
+                execSync('git rev-parse upstream/main', { stdio: 'pipe' });
+            } catch {
+                defaultBranch = 'master';
+            }
+
+            // 2. Checkout default branch before syncing
+            try {
+                execSync(`git checkout ${defaultBranch}`, { stdio: 'pipe' });
+            } catch {
+                // If it fails, maybe it's not even a valid default branch locally, but we'll try to sync anyway
+            }
+
+            await syncBranch();
+
+            // 3. Create or switch to issue branch
+            const branchName = issue ? `fix/issue-${issue}` : null;
+            if (branchName) {
+                try {
+                    execSync(`git checkout -b ${branchName}`, { stdio: 'pipe' });
+                    console.log(green(`  ✔ Created branch ${branchName}`));
+                } catch {
+                    execSync(`git checkout ${branchName}`, { stdio: 'pipe' });
+                    console.log(green(`  ✔ Switched to branch ${branchName}`));
+                }
+            }
+
+            console.log(green('\n✨ Workspace ready!'));
+            return;
+        }
+
+        // Directory exists but isn't a valid clone — ask for new path
+        const { newDir } = await inquirer.prompt([{
+            type: 'input',
+            name: 'newDir',
+            message: yellow(`"${cloneDir}" already exists. Enter a different folder name:`),
+            default: `${repo}-contrib`,
+        }]);
+        cloneDir = path.resolve(resolvedParent, newDir);
+    }
+
+    // 4. Clone
+    const cloneSpinner = ora(`Cloning your fork...`).start();
+    const cloneUrl = `https://github.com/${myUser}/${repo}.git`;
+
+    try {
+        execSync(`git clone ${cloneUrl} ${cloneDir}`, { stdio: 'pipe' });
+        cloneSpinner.succeed(`Cloned into ${green(cloneDir)}`);
+    } catch (e: any) {
+        cloneSpinner.fail(`Clone failed: ${e.message}`);
+        return;
+    }
+
+    // 5. Setup Remotes & Branch
+    process.chdir(cloneDir);
+    execSync(`git remote add upstream https://github.com/${owner}/${repo}.git`, { stdio: 'pipe' });
+
+    const branchName = issue ? `fix/issue-${issue}` : `contrib-${Math.floor(Date.now() / 1000)}`;
+
+    try {
+        execSync(`git checkout -b ${branchName}`, { stdio: 'pipe' });
+    } catch {
+        execSync(`git checkout ${branchName}`, { stdio: 'pipe' });
+    }
+
+    // Update local GitPadi state
+    setRepo(owner, repo);
+
+    console.log(`\n${green('✨ Workspace Ready!')}`);
+    console.log(`${dim('Directory:')}  ${cloneDir}`);
+    console.log(`${dim('Branch:')}     ${branchName}`);
+    console.log(`${dim('Upstream:')}   ${owner}/${repo}`);
+
+    console.log(boxen(
+        green('Next step:\n') +
+        white(`cd ${cloneDir}\n\n`) +
+        dim('Start coding! When you\'re done, run ') + yellow('gitpadi submit'),
+        { padding: 1, borderColor: 'green', borderStyle: 'round' }
+    ));
+}
+
+/**
+ * Phase 2: Sync Fork with Upstream (full flow)
+ * 1. Sync fork on GitHub (API)
+ * 2. Pull synced changes locally
+ * 3. Merge upstream into current branch
+ */
+export async function syncBranch() {
+    try {
+        // Check if we are in a git repo and if upstream exists
+        const remotes = execSync('git remote', { encoding: 'utf-8' });
+        if (!remotes.includes('upstream')) return;
+
+        const spinner = ora('Syncing fork...').start();
+
+        // 1. Detect upstream default branch (main or master)
+        execSync('git fetch upstream', { stdio: 'pipe' });
+        let upstreamBranch = 'main';
+        try {
+            execSync('git rev-parse upstream/main', { stdio: 'pipe' });
+        } catch {
+            upstreamBranch = 'master';
+        }
+
+        // 2. Sync fork on GitHub via API
+        spinner.text = 'Syncing fork on GitHub...';
+        try {
+            const octokit = getOctokit();
+            const myUser = await getAuthenticatedUser();
+            const repo = getRepo();
+            await octokit.request('POST /repos/{owner}/{repo}/merge-upstream', {
+                owner: myUser,
+                repo: repo,
+                branch: upstreamBranch,
+            });
+            spinner.succeed(green('Fork synced on GitHub ✓'));
+        } catch (e: any) {
+            // May fail if already in sync or permissions — continue anyway
+            spinner.info(dim('GitHub sync skipped (may already be in sync)'));
+        }
+
+        // 3. Pull synced changes locally
+        const pullSpinner = ora('Pulling latest changes...').start();
+        const currentBranch = execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf-8' }).trim();
+
+        // Fetch origin (our fork) with the new synced data
+        execSync('git fetch origin', { stdio: 'pipe' });
+        execSync('git fetch upstream', { stdio: 'pipe' });
+
+        // If we're on main/master, just pull
+        if (currentBranch === upstreamBranch) {
+            try {
+                execSync(`git pull origin ${upstreamBranch} --no-edit`, { stdio: 'pipe' });
+                pullSpinner.succeed(green(`Pulled latest ${upstreamBranch} ✓`));
+            } catch {
+                pullSpinner.warn(yellow('Pull had conflicts — resolve manually'));
+            }
+        } else {
+            // We're on a feature branch — merge upstream into it
+            pullSpinner.text = `Merging upstream/${upstreamBranch} into ${currentBranch}...`;
+            try {
+                execSync(`git merge upstream/${upstreamBranch} --no-edit`, { stdio: 'pipe' });
+                pullSpinner.succeed(green(`Merged upstream/${upstreamBranch} into ${cyan(currentBranch)} ✓`));
+            } catch {
+                pullSpinner.warn(yellow('Merge conflict detected!'));
+                console.log(dim('  Resolve conflicts, then run:'));
+                console.log(dim('  git add . && git commit'));
+            }
+        }
+
+        console.log(green('\n✨ Fork is synced and up to date!'));
+    } catch (e: any) {
+        // Silently fail if git commands error (likely not in a repo)
+    }
+}
+
+/**
+ * Phase 2: Submit PR
+ */
+export async function submitPR(opts: { title: string, body?: string, issue?: number, message?: string }) {
+    const spinner = ora('Preparing submission...').start();
+    try {
+        const owner = getOwner();
+        const repo = getRepo();
+        const branch = execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf-8' }).trim();
+
+        // 1. Stage and Commit
+        spinner.text = 'Staging and committing changes...';
+        const commitMsg = opts.message || opts.title || 'Automated contribution via GitPadi';
+
+        try {
+            execSync('git add .', { stdio: 'pipe' });
+            // Check if there are changes to commit
+            const status = execSync('git status --porcelain', { encoding: 'utf-8' });
+            if (status.trim()) {
+                execSync(`git commit -m "${commitMsg.replace(/"/g, '\\"')}"`, { stdio: 'pipe' });
+            }
+        } catch (e: any) {
+            // If commit fails (e.g. no changes), we might still want to push if there are unpushed commits
+            dim('  (Note: No new changes to commit or commit failed)');
+        }
+
+        // Auto-infer issue from branch name (e.g. fix/issue-303)
+        let linkedIssue = opts.issue;
+        if (!linkedIssue) {
+            const match = branch.match(/issue-(\d+)/);
+            if (match) linkedIssue = parseInt(match[1]);
+        }
+
+        spinner.text = 'Pushing to your fork...';
+        execSync(`git push origin ${branch}`, { stdio: 'pipe' });
+
+        spinner.text = 'Creating Pull Request...';
+        const body = opts.body || (linkedIssue ? `Fixes #${linkedIssue}` : 'Automated PR via GitPadi');
+
+        // Detect base branch
+        let baseBranch = 'main';
+        try {
+            execSync('git rev-parse origin/main', { stdio: 'pipe' });
+        } catch {
+            baseBranch = 'master';
+        }
+
+        const { data: pr } = await getOctokit().pulls.create({
+            owner,
+            repo,
+            title: opts.title,
+            body,
+            head: `${await getAuthenticatedUser()}:${branch}`,
+            base: baseBranch,
+        });
+
+        spinner.succeed(`PR Created: ${green(pr.html_url)}`);
+    } catch (e: any) {
+        spinner.fail(e.message);
+    }
+}
+
+/**
+ * Phase 2: View Logs
+ */
+export async function viewLogs() {
+    const spinner = ora('Fetching GitHub Action logs...').start();
+    try {
+        const owner = getOwner();
+        const repo = getRepo();
+        const sha = execSync('git rev-parse HEAD', { encoding: 'utf-8' }).trim();
+
+        const { checkRuns, combinedState } = await getLatestCheckRuns(owner, repo, sha);
+        spinner.stop();
+
+        if (checkRuns.length === 0) {
+            console.log(dim('\n  ℹ️ No active check runs found for this commit.\n'));
+            return;
+        }
+
+        console.log(`\n${chalk.bold(`📋 GitHub Actions status:`)} ${combinedState === 'success' ? green('✅ Success') : combinedState === 'failure' ? chalk.red('❌ Failure') : yellow('⏳ Pending')}\n`);
+
+        checkRuns.forEach(run => {
+            const icon = run.status === 'completed' ? (run.conclusion === 'success' ? green('✅') : chalk.red('❌')) : yellow('⏳');
+            console.log(`  ${icon} ${chalk.bold(run.name)}: ${dim(run.conclusion || run.status)}`);
+            if (run.conclusion === 'failure') {
+                console.log(chalk.red(`     → Build failed. View details at: ${run.html_url}`));
+            }
+        });
+        console.log('');
+    } catch (e: any) {
+        spinner.fail(e.message);
+    }
+}

package/src/commands/issues.ts

@@ -14,18 +14,34 @@ export async function listIssues(opts: { state?: string; labels?: string; limit?
     const spinner = ora(`Fetching issues from ${chalk.cyan(getFullRepo())}...`).start();
 
     try {
-        const { data: issues } = await octokit.issues.listForRepo({
-            owner: getOwner(), repo: getRepo(),
-            state: (opts.state as 'open' | 'closed' | 'all') || 'open',
-            labels: opts.labels || undefined,
-            per_page: opts.limit || 50,
-        });
+        const requestedLimit = opts.limit || 50;
+        const realIssues: any[] = [];
+        let page = 1;
+
+        // Fetch until we have enough real issues or run out of pages
+        while (realIssues.length < requestedLimit) {
+            const { data: issues } = await octokit.issues.listForRepo({
+                owner: getOwner(), repo: getRepo(),
+                state: (opts.state as 'open' | 'closed' | 'all') || 'open',
+                labels: opts.labels || undefined,
+                per_page: 100, // Fetch max per page to be efficient
+                page: page++,
+            });
+
+            if (issues.length === 0) break;
+
+            const batch = issues.filter((i) => !i.pull_request);
+            realIssues.push(...batch);
+
+            if (issues.length < 100) break; // Last page
+        }
+
+        // Clip to requested limit
+        const finalIssues = realIssues.slice(0, requestedLimit);
 
-        // Filter out PRs (GitHub API returns PRs in issues endpoint)
-        const realIssues = issues.filter((i) => !i.pull_request);
         spinner.stop();
 
-        if (realIssues.length === 0) {
+        if (finalIssues.length === 0) {
             console.log(chalk.yellow('\n  No issues found.\n'));
             return;
         }
@@ -35,14 +51,14 @@ export async function listIssues(opts: { state?: string; labels?: string; limit?
             style: { head: [], border: [] },
         });
 
-        realIssues.forEach((i) => {
-            const labels = i.labels.map((l) => typeof l === 'string' ? l : l.name || '').join(', ');
+        finalIssues.forEach((i) => {
+            const labels = i.labels.map((l: any) => typeof l === 'string' ? l : l.name || '').join(', ');
             const assignee = i.assignee?.login || chalk.dim('unassigned');
             const state = i.state === 'open' ? chalk.green('open') : chalk.red('closed');
             table.push([`#${i.number}`, i.title.substring(0, 60), labels.substring(0, 30), assignee, state]);
         });
 
-        console.log(`\n${chalk.bold(`📋 Issues — ${getFullRepo()}`)} (${realIssues.length})\n`);
+        console.log(`\n${chalk.bold(`📋 Issues — ${getFullRepo()}`)} (${finalIssues.length})\n`);
         console.log(table.toString());
         console.log('');
     } catch (e: any) {
@@ -70,6 +86,46 @@ export async function createIssue(opts: { title: string; body?: string; labels?:
     }
 }
 
+/**
+ * Parse a markdown file into issues.
+ * Format:
+ *   ## Issue Title
+ *   **Labels:** bug, frontend
+ *   Body text here...
+ */
+function parseMarkdownIssues(content: string): { issues: any[]; labels: Record<string, string> } {
+    const issues: any[] = [];
+    const sections = content.split(/^## /m).filter(s => s.trim());
+
+    let num = 1;
+    for (const section of sections) {
+        const lines = section.split('\n');
+        const title = lines[0].trim();
+        if (!title) continue;
+
+        let labels: string[] = [];
+        const bodyLines: string[] = [];
+
+        for (let i = 1; i < lines.length; i++) {
+            const labelsMatch = lines[i].match(/^\*\*Labels?:\*\*\s*(.+)/i);
+            if (labelsMatch) {
+                labels = labelsMatch[1].split(',').map(l => l.trim()).filter(Boolean);
+            } else {
+                bodyLines.push(lines[i]);
+            }
+        }
+
+        issues.push({
+            number: num++,
+            title,
+            body: bodyLines.join('\n').trim(),
+            labels,
+        });
+    }
+
+    return { issues, labels: {} };
+}
+
 export async function createIssuesFromFile(filePath: string, opts: { dryRun?: boolean; start?: number; end?: number }) {
     requireRepo();
     const resolved = path.resolve(filePath);
@@ -78,24 +134,60 @@ export async function createIssuesFromFile(filePath: string, opts: { dryRun?: bo
         return;
     }
 
-    const config = JSON.parse(fs.readFileSync(resolved, 'utf-8'));
-    const issues = config.issues || [];
+    const raw = fs.readFileSync(resolved, 'utf-8');
+    const ext = path.extname(resolved).toLowerCase();
+
+    let config: { issues: any[]; labels?: Record<string, string> };
+    let detectedFormat = 'JSON';
+
+    if (ext === '.md' || ext === '.markdown') {
+        config = parseMarkdownIssues(raw);
+        detectedFormat = 'Markdown';
+    } else {
+        // Try JSON first, fallback to Markdown if it fails
+        try {
+            const parsed = JSON.parse(raw);
+            config = { issues: parsed.issues || [], labels: parsed.labels };
+        } catch {
+            // Not valid JSON — try markdown parser
+            if (raw.trimStart().startsWith('#')) {
+                console.log(chalk.yellow(`\n  ⚠ File has .json extension but contains Markdown — parsing as Markdown.\n`));
+                config = parseMarkdownIssues(raw);
+                detectedFormat = 'Markdown (auto-detected)';
+            } else {
+                console.error(chalk.red(`\n  ❌ Fatal: File is not valid JSON or Markdown.\n`));
+                return;
+            }
+        }
+    }
+
+    const issues = config.issues;
     const start = opts.start || 1;
     const end = opts.end || 999;
     const filtered = issues.filter((i: any) => i.number >= start && i.number <= end);
 
     console.log(`\n${chalk.bold('📋 GitPadi Issue Creator')}`);
-    console.log(chalk.dim(`  Repo:  ${getFullRepo()}`));
-    console.log(chalk.dim(`  File:  ${filePath}`));
-    console.log(chalk.dim(`  Range: #${start}-#${end} (${filtered.length} issues)`));
-    console.log(chalk.dim(`  Mode:  ${opts.dryRun ? 'DRY RUN' : 'LIVE'}\n`));
-
-    if (opts.dryRun) {
-        filtered.forEach((i: any) => {
-            console.log(`  ${chalk.dim(`#${String(i.number).padStart(2, '0')}`)}  ${i.title}`);
-            console.log(chalk.dim(`       [${i.labels.join(', ')}]`));
-        });
-        console.log(chalk.green(`\n✅ Dry run: ${filtered.length} issues would be created.\n`));
+    console.log(chalk.dim(`  Repo:   ${getFullRepo()}`));
+    console.log(chalk.dim(`  File:   ${filePath} (${detectedFormat})`));
+    console.log(chalk.dim(`  Found:  ${filtered.length} issues\n`));
+
+    // Always preview first
+    filtered.forEach((i: any) => {
+        console.log(`  ${chalk.dim(`#${String(i.number).padStart(2, '0')}`)}  ${i.title}`);
+        console.log(chalk.dim(`       [${(i.labels || []).join(', ')}]`));
+    });
+
+    // Ask for confirmation
+    const inquirer = (await import('inquirer')).default;
+    const { proceed } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'proceed',
+        message: chalk.yellow(`Create these ${filtered.length} issues on GitHub?`),
+        default: true,
+    }]);
+
+    if (!proceed) {
+        console.log(chalk.dim('\n  Cancelled.\n'));
         return;
     }
 
@@ -103,7 +195,7 @@ export async function createIssuesFromFile(filePath: string, opts: { dryRun?: bo
     let created = 0, failed = 0;
 
     // Create labels if defined
-    if (config.labels) {
+    if (config.labels && Object.keys(config.labels).length > 0) {
         const spinner = ora('Setting up labels...').start();
         try {
             for (const [name, color] of Object.entries(config.labels)) {

package/src/commands/repos.ts

@@ -52,7 +52,11 @@ export async function cloneRepo(name: string, opts: { org?: string; dir?: string
     try {
         execSync(`git clone ${url} ${dir}`, { stdio: 'pipe' });
         spinner.succeed(`Cloned to ${chalk.green(`./${dir}`)}`);
-    } catch (e: any) { spinner.fail(`Clone failed: ${e.message}`); }
+        return true;
+    } catch (e: any) {
+        spinner.fail(`Clone failed: ${e.message}`);
+        return false;
+    }
 }
 
 export async function repoInfo(name: string, opts: { org?: string }) {
@@ -80,7 +84,11 @@ export async function repoInfo(name: string, opts: { org?: string }) {
 
         console.log(table.toString());
         console.log('');
-    } catch (e: any) { spinner.fail(e.message); }
+        return repo;
+    } catch (e: any) {
+        spinner.fail(e.message);
+        return null;
+    }
 }
 
 export async function setTopics(name: string, topics: string[], opts: { org?: string }) {
@@ -93,37 +101,44 @@ export async function setTopics(name: string, topics: string[], opts: { org?: st
     } catch (e: any) { spinner.fail(e.message); }
 }
 
-export async function listRepos(opts: { org?: string; limit?: number }) {
-    const spinner = ora('Fetching repos...').start();
+export async function listRepos(opts: { org?: string; limit?: number; silent?: boolean }) {
+    const spinner = !opts.silent ? ora('Fetching repos...').start() : null;
     const octokit = getOctokit();
 
     try {
         let repos: any[];
         if (opts.org) {
-            ({ data: repos } = await octokit.repos.listForOrg({ org: opts.org, per_page: opts.limit || 50, sort: 'updated' }));
+            ({ data: repos } = await octokit.repos.listForOrg({ org: opts.org, per_page: opts.limit || 100, sort: 'updated' }));
         } else {
-            ({ data: repos } = await octokit.repos.listForAuthenticatedUser({ per_page: opts.limit || 50, sort: 'updated' }));
+            ({ data: repos } = await octokit.repos.listForAuthenticatedUser({ per_page: opts.limit || 100, sort: 'updated' }));
         }
 
-        spinner.stop();
+        if (spinner) spinner.stop();
+
+        if (!opts.silent) {
+            const table = new Table({
+                head: ['Name', 'Stars', 'Language', 'Visibility', 'Updated'].map((h) => chalk.cyan(h)),
+                style: { head: [], border: [] },
+            });
+
+            repos.forEach((r: any) => {
+                table.push([
+                    r.full_name,
+                    `⭐ ${r.stargazers_count}`,
+                    r.language || '-',
+                    r.private ? chalk.yellow('private') : chalk.green('public'),
+                    new Date(r.updated_at).toLocaleDateString(),
+                ]);
+            });
+
+            console.log(`\n${chalk.bold('📦 Repositories')} (${repos.length})\n`);
+            console.log(table.toString());
+            console.log('');
+        }
 
-        const table = new Table({
-            head: ['Name', 'Stars', 'Language', 'Visibility', 'Updated'].map((h) => chalk.cyan(h)),
-            style: { head: [], border: [] },
-        });
-
-        repos.forEach((r: any) => {
-            table.push([
-                r.full_name,
-                `⭐ ${r.stargazers_count}`,
-                r.language || '-',
-                r.private ? chalk.yellow('private') : chalk.green('public'),
-                new Date(r.updated_at).toLocaleDateString(),
-            ]);
-        });
-
-        console.log(`\n${chalk.bold('📦 Repositories')} (${repos.length})\n`);
-        console.log(table.toString());
-        console.log('');
-    } catch (e: any) { spinner.fail(e.message); }
+        return repos;
+    } catch (e: any) {
+        if (spinner) spinner.fail(e.message);
+        return [];
+    }
 }