gitpadi 2.0.0 → 2.0.2

package/dist/commands/contribute.js

@@ -0,0 +1,291 @@
+// 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) {
+    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) {
+    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;
+    try {
+        myUser = await getAuthenticatedUser();
+        const forkFullName = await forkRepo(owner, repo);
+        spinner.succeed(`Forked to ${green(forkFullName)}`);
+    }
+    catch (e) {
+        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 = 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 */ }
+            await syncBranch();
+            // 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) {
+        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) {
+            // 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) {
+        // Silently fail if git commands error (likely not in a repo)
+    }
+}
+/**
+ * Phase 2: Submit PR
+ */
+export async function submitPR(opts) {
+    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) {
+            // 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');
+        const { data: pr } = await getOctokit().pulls.create({
+            owner,
+            repo,
+            title: opts.title,
+            body,
+            head: `${await getAuthenticatedUser()}:${branch}`,
+            base: 'main',
+        });
+        spinner.succeed(`PR Created: ${green(pr.html_url)}`);
+    }
+    catch (e) {
+        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) {
+        spinner.fail(e.message);
+    }
+}

package/dist/commands/contributors.js

@@ -0,0 +1,101 @@
+// commands/contributors.ts — Contributor management commands for GitPadi
+import chalk from 'chalk';
+import ora from 'ora';
+import Table from 'cli-table3';
+import { getOctokit, getOwner, getRepo, getFullRepo, requireRepo } from '../core/github.js';
+import { fetchProfile, scoreApplicant, TIER_EMOJI } from '../core/scorer.js';
+export async function scoreUser(username) {
+    requireRepo();
+    const spinner = ora(`Scoring @${username}...`).start();
+    try {
+        const profile = await fetchProfile(username);
+        const scored = scoreApplicant(profile);
+        spinner.stop();
+        console.log(`\n${chalk.bold(`🏆 Score: @${username}`)} — ${TIER_EMOJI[scored.tier]} Tier ${scored.tier} (${scored.score}/100)\n`);
+        const table = new Table({ style: { head: [], border: [] } });
+        table.push({ [chalk.cyan('🏛️ Account Maturity')]: `${scored.breakdown.accountMaturity}/15` }, { [chalk.cyan('🔧 Repo Experience')]: `${scored.breakdown.repoExperience}/30` }, { [chalk.cyan('🌐 GitHub Presence')]: `${scored.breakdown.githubPresence}/15` }, { [chalk.cyan('⚡ Activity Level')]: `${scored.breakdown.activityLevel}/15` }, { [chalk.cyan('📝 Application')]: `${scored.breakdown.applicationQuality}/15` }, { [chalk.cyan('💻 Languages')]: `${scored.breakdown.languageRelevance}/10` }, { [chalk.bold('Total')]: chalk.bold(`${scored.score}/100`) });
+        console.log(table.toString());
+        console.log(`\n  ${chalk.dim('Account age:')} ${Math.round(scored.accountAge / 30)} months`);
+        console.log(`  ${chalk.dim('Public repos:')} ${scored.publicRepos}`);
+        console.log(`  ${chalk.dim('Followers:')} ${scored.followers}`);
+        console.log(`  ${chalk.dim('Languages:')} ${scored.relevantLanguages.slice(0, 8).join(', ') || 'None detected'}`);
+        console.log(`  ${chalk.dim('Repo PRs:')} ${scored.prsMerged} merged, ${scored.prsOpen} open`);
+        console.log('');
+    }
+    catch (e) {
+        spinner.fail(e.message);
+    }
+}
+export async function rankApplicants(issueNumber) {
+    requireRepo();
+    const octokit = getOctokit();
+    const spinner = ora(`Finding applicants for #${issueNumber}...`).start();
+    try {
+        const { data: issue } = await octokit.issues.get({ owner: getOwner(), repo: getRepo(), issue_number: issueNumber });
+        const { data: comments } = await octokit.issues.listComments({ owner: getOwner(), repo: getRepo(), issue_number: issueNumber, per_page: 100 });
+        const labels = issue.labels.map((l) => typeof l === 'string' ? l : l.name || '').filter(Boolean);
+        const { isApplicationComment } = await import('../core/scorer.js');
+        const apps = comments.filter((c) => c.body && isApplicationComment(c.body) && c.user?.login !== 'github-actions[bot]');
+        const byUser = new Map();
+        apps.forEach((c) => { if (c.user?.login)
+            byUser.set(c.user.login, c.body || ''); });
+        if (byUser.size === 0) {
+            spinner.warn('No applicants found.');
+            return;
+        }
+        spinner.text = `Scoring ${byUser.size} applicant(s)...`;
+        const scored = [];
+        for (const [user, body] of byUser) {
+            const profile = await fetchProfile(user, body);
+            scored.push(scoreApplicant(profile, labels));
+        }
+        scored.sort((a, b) => b.score - a.score);
+        spinner.stop();
+        const table = new Table({
+            head: ['Rank', 'User', 'Tier', 'Score', 'PRs', 'Activity', 'Languages'].map((h) => chalk.cyan(h)),
+            style: { head: [], border: [] },
+        });
+        scored.forEach((s, i) => {
+            const medal = i === 0 ? '🥇' : i === 1 ? '🥈' : i === 2 ? '🥉' : `${i + 1}.`;
+            table.push([medal, `@${s.username}`, `${TIER_EMOJI[s.tier]} ${s.tier}`, `${s.score}/100`, `${s.prsMerged}m/${s.prsOpen}o`, `${s.totalContributions}`, s.relevantLanguages.slice(0, 3).join(', ') || '-']);
+        });
+        console.log(`\n${chalk.bold(`🏆 Applicant Rankings — Issue #${issueNumber}`)}\n`);
+        console.log(table.toString());
+        if (scored.length >= 2) {
+            const gap = scored[0].score - scored[1].score;
+            if (gap >= 20)
+                console.log(chalk.green(`\n  → Clear winner: @${scored[0].username} (+${gap} pts)`));
+            else if (gap >= 5)
+                console.log(chalk.green(`\n  → Top pick: @${scored[0].username} (+${gap} pts)`));
+            else
+                console.log(chalk.yellow(`\n  → Close match — review manually`));
+        }
+        console.log('');
+    }
+    catch (e) {
+        spinner.fail(e.message);
+    }
+}
+export async function listContributors(opts) {
+    requireRepo();
+    const spinner = ora('Fetching contributors...').start();
+    try {
+        const { data } = await getOctokit().repos.listContributors({
+            owner: getOwner(), repo: getRepo(), per_page: opts.limit || 50,
+        });
+        spinner.stop();
+        const table = new Table({
+            head: ['#', 'User', 'Contributions'].map((h) => chalk.cyan(h)),
+            style: { head: [], border: [] },
+        });
+        data.forEach((c, i) => {
+            table.push([`${i + 1}.`, `@${c.login || '?'}`, `${c.contributions}`]);
+        });
+        console.log(`\n${chalk.bold(`👥 Contributors — ${getFullRepo()}`)} (${data.length})\n`);
+        console.log(table.toString());
+        console.log('');
+    }
+    catch (e) {
+        spinner.fail(e.message);
+    }
+}