gitpadi 2.0.6 → 2.1.1

package/src/commands/contribute.ts

@@ -2,7 +2,7 @@
 
 import chalk from 'chalk';
 import ora from 'ora';
-import { execSync } from 'child_process';
+import { execSync, execFileSync } from 'child_process';
 import * as fs from 'fs';
 import boxen from 'boxen';
 import {
@@ -31,7 +31,7 @@ function parseTarget(input: string): { owner: string, repo: string, issue?: numb
     if (match) {
         return {
             owner: match[1],
-            repo: match[2],
+            repo: match[2].replace(/\.git$/, ''),
             issue: match[4] ? parseInt(match[4]) : undefined
         };
     }
@@ -44,6 +44,15 @@ function parseTarget(input: string): { owner: string, repo: string, issue?: numb
     throw new Error('Invalid target. Use a GitHub URL or "owner/repo" format.');
 }
 
+/** Safe git wrapper — uses execFileSync to avoid shell injection */
+function git(args: string[], opts: { cwd?: string; stdio?: 'pipe' | 'inherit' | 'ignore' } = {}): string {
+    return execFileSync('git', args, {
+        encoding: 'utf-8',
+        stdio: opts.stdio ?? 'pipe',
+        cwd: opts.cwd,
+    }) as string;
+}
+
 /**
  * Phase 2: Fork & Clone Workflow (The "Start" Command)
  */
@@ -58,6 +67,9 @@ export async function forkAndClone(target: string) {
         myUser = await getAuthenticatedUser();
         const forkFullName = await forkRepo(owner, repo);
         spinner.succeed(`Forked to ${green(forkFullName)}`);
+
+        // Give GitHub a moment to prepare the fork
+        await new Promise(r => setTimeout(r, 2000));
     } catch (e: any) {
         spinner.fail(e.message);
         return;
@@ -86,7 +98,7 @@ export async function forkAndClone(target: string) {
         // 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();
+            const remoteUrl = git(['remote', 'get-url', 'origin'], { cwd: cloneDir }).trim();
             if (remoteUrl.includes(repo)) isValidClone = true;
         } catch { /* not a git repo */ }
 
@@ -98,21 +110,24 @@ export async function forkAndClone(target: string) {
             setRepo(owner, repo);
 
             // Ensure upstream remote exists
-            try { execSync(`git remote add upstream https://github.com/${owner}/${repo}.git`, { stdio: 'pipe' }); } catch { /* exists */ }
+            try { git(['remote', 'add', 'upstream', `https://github.com/${owner}/${repo}.git`], { stdio: 'ignore' }); } catch { /* exists */ }
 
             // 1. Detect default branch
             let defaultBranch = 'main';
             try {
-                execSync('git rev-parse upstream/main', { stdio: 'pipe' });
+                git(['rev-parse', 'upstream/main'], { stdio: 'ignore' });
             } catch {
                 defaultBranch = 'master';
             }
 
             // 2. Checkout default branch before syncing
             try {
-                execSync(`git checkout ${defaultBranch}`, { stdio: 'pipe' });
+                const current = git(['rev-parse', '--abbrev-ref', 'HEAD']).trim();
+                if (current !== defaultBranch) {
+                    git(['checkout', defaultBranch], { stdio: 'ignore' });
+                }
             } catch {
-                // If it fails, maybe it's not even a valid default branch locally, but we'll try to sync anyway
+                // Ignore checkout failures for default branch
             }
 
             await syncBranch();
@@ -120,12 +135,24 @@ export async function forkAndClone(target: string) {
             // 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}`));
+                const current = git(['rev-parse', '--abbrev-ref', 'HEAD']).trim();
+                if (current !== branchName) {
+                    try {
+                        git(['checkout', '-b', branchName], { stdio: 'ignore' });
+                        console.log(green(`  ✔ Created branch ${branchName}`));
+                    } catch {
+                        try {
+                            git(['checkout', branchName], { stdio: 'ignore' });
+                            console.log(green(`  ✔ Switched to branch ${branchName}`));
+                        } catch (e: any) {
+                            const nowBranch = git(['rev-parse', '--abbrev-ref', 'HEAD']).trim();
+                            if (nowBranch === branchName) {
+                                console.log(green(`  ✔ On branch ${branchName} (warning: some git hooks may have failed)`));
+                            } else {
+                                console.warn(yellow(`  ⚠️  Warning: Could not switch to branch ${branchName}: ${e.message}`));
+                            }
+                        }
+                    }
                 }
             }
 
@@ -143,28 +170,34 @@ export async function forkAndClone(target: string) {
         cloneDir = path.resolve(resolvedParent, newDir);
     }
 
-    // 4. Clone
-    const cloneSpinner = ora(`Cloning your fork...`).start();
+    // 4. Clone (use execFileSync — no shell interpolation)
     const cloneUrl = `https://github.com/${myUser}/${repo}.git`;
+    console.log(dim(`  ▸ Cloning from ${cloneUrl}...`));
 
     try {
-        execSync(`git clone ${cloneUrl} ${cloneDir}`, { stdio: 'pipe' });
-        cloneSpinner.succeed(`Cloned into ${green(cloneDir)}`);
+        execFileSync('git', ['clone', cloneUrl, cloneDir], { stdio: 'inherit' });
+        console.log(green(`\n  ✔ Cloned successfully`));
     } catch (e: any) {
-        cloneSpinner.fail(`Clone failed: ${e.message}`);
+        console.error(chalk.red(`\n  ❌ Clone failed. Please check your internet connection and GitHub permissions.`));
         return;
     }
 
+    ora().succeed(`Setup complete for ${green(cloneDir)}`);
+
     // 5. Setup Remotes & Branch
     process.chdir(cloneDir);
-    execSync(`git remote add upstream https://github.com/${owner}/${repo}.git`, { stdio: 'pipe' });
+    git(['remote', 'add', 'upstream', `https://github.com/${owner}/${repo}.git`], { stdio: 'ignore' });
 
     const branchName = issue ? `fix/issue-${issue}` : `contrib-${Math.floor(Date.now() / 1000)}`;
 
     try {
-        execSync(`git checkout -b ${branchName}`, { stdio: 'pipe' });
+        git(['checkout', '-b', branchName], { stdio: 'ignore' });
     } catch {
-        execSync(`git checkout ${branchName}`, { stdio: 'pipe' });
+        try {
+            git(['checkout', branchName], { stdio: 'ignore' });
+        } catch {
+            // Ignore hook failures
+        }
     }
 
     // Update local GitPadi state
@@ -192,16 +225,16 @@ export async function forkAndClone(target: string) {
 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' });
+        const remotes = git(['remote']);
         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' });
+        git(['fetch', 'upstream'], { stdio: 'pipe' });
         let upstreamBranch = 'main';
         try {
-            execSync('git rev-parse upstream/main', { stdio: 'pipe' });
+            git(['rev-parse', 'upstream/main'], { stdio: 'pipe' });
         } catch {
             upstreamBranch = 'master';
         }
@@ -225,16 +258,16 @@ export async function syncBranch() {
 
         // 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();
+        const currentBranch = git(['rev-parse', '--abbrev-ref', 'HEAD']).trim();
 
         // Fetch origin (our fork) with the new synced data
-        execSync('git fetch origin', { stdio: 'pipe' });
-        execSync('git fetch upstream', { stdio: 'pipe' });
+        git(['fetch', 'origin'], { stdio: 'pipe' });
+        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' });
+                git(['pull', 'origin', upstreamBranch, '--no-edit'], { stdio: 'pipe' });
                 pullSpinner.succeed(green(`Pulled latest ${upstreamBranch} ✓`));
             } catch {
                 pullSpinner.warn(yellow('Pull had conflicts — resolve manually'));
@@ -243,7 +276,7 @@ export async function syncBranch() {
             // 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' });
+                git(['merge', `upstream/${upstreamBranch}`, '--no-edit'], { stdio: 'pipe' });
                 pullSpinner.succeed(green(`Merged upstream/${upstreamBranch} into ${cyan(currentBranch)} ✓`));
             } catch {
                 pullSpinner.warn(yellow('Merge conflict detected!'));
@@ -266,7 +299,7 @@ export async function submitPR(opts: { title: string, body?: string, issue?: num
     try {
         const owner = getOwner();
         const repo = getRepo();
-        const branch = execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf-8' }).trim();
+        const branch = git(['rev-parse', '--abbrev-ref', 'HEAD']).trim();
 
         // Auto-infer issue from branch name (e.g. fix/issue-303)
         let linkedIssue = opts.issue;
@@ -277,42 +310,35 @@ export async function submitPR(opts: { title: string, body?: string, issue?: num
 
         const octokit = getOctokit();
 
-        // 2. Fetch Issue Details for better PR Metadata
+        // Fetch Issue Details for better PR Metadata
         let issueTitle = '';
         if (linkedIssue) {
             spinner.text = `Fetching details for issue #${linkedIssue}...`;
             try {
-                const { data: issueData } = await octokit.issues.get({
-                    owner,
-                    repo,
-                    issue_number: linkedIssue,
-                });
+                const { data: issueData } = await octokit.issues.get({ owner, repo, issue_number: linkedIssue });
                 issueTitle = issueData.title;
-            } catch (e) {
-                // Silently fallback if issue doesn't exist or no access
-            }
+            } catch { /* Silently fallback */ }
         }
 
         const prTitle = opts.title || (issueTitle ? `fix: ${issueTitle} (#${linkedIssue})` : 'Automated contribution via GitPadi');
         const commitMsg = opts.message || prTitle;
 
-        // 1. Stage and Commit
+        // Stage and Commit
         spinner.text = 'Staging and committing changes...';
 
         try {
-            execSync('git add .', { stdio: 'pipe' });
-            // Check if there are changes to commit
-            const status = execSync('git status --porcelain', { encoding: 'utf-8' });
+            git(['add', '.'], { stdio: 'pipe' });
+            const status = git(['status', '--porcelain']);
             if (status.trim()) {
-                execSync(`git commit -m "${commitMsg.replace(/"/g, '\\"')}"`, { stdio: 'pipe' });
+                // Use execFileSync to avoid shell injection on commit message
+                execFileSync('git', ['commit', '-m', commitMsg], { 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)');
+        } catch {
+            // No new changes to commit or commit failed — continue to push anyway
         }
 
         spinner.text = 'Pushing to your fork...';
-        execSync(`git push origin ${branch}`, { stdio: 'pipe' });
+        git(['push', 'origin', branch], { stdio: 'pipe' });
 
         spinner.text = 'Creating Pull Request...';
         const body = opts.body || (linkedIssue ? `Fixes #${linkedIssue}` : 'Automated PR via GitPadi');
@@ -320,7 +346,7 @@ export async function submitPR(opts: { title: string, body?: string, issue?: num
         // Detect base branch
         let baseBranch = 'main';
         try {
-            execSync('git rev-parse origin/main', { stdio: 'pipe' });
+            git(['rev-parse', 'origin/main'], { stdio: 'pipe' });
         } catch {
             baseBranch = 'master';
         }
@@ -348,7 +374,7 @@ export async function viewLogs() {
     try {
         const owner = getOwner();
         const repo = getRepo();
-        const sha = execSync('git rev-parse HEAD', { encoding: 'utf-8' }).trim();
+        const sha = git(['rev-parse', 'HEAD']).trim();
 
         const { checkRuns, combinedState } = await getLatestCheckRuns(owner, repo, sha);
         spinner.stop();
@@ -372,3 +398,191 @@ export async function viewLogs() {
         spinner.fail(e.message);
     }
 }
+
+/**
+ * Phase 8: Fix & Re-push (CI Failure Recovery)
+ * Shows failed checks, waits for user to fix, then amends commit and force-pushes.
+ */
+export async function fixAndRepush() {
+    const inquirer = (await import('inquirer')).default;
+
+    // 1. Show current CI status
+    console.log(yellow('\n  🔧 Fix & Re-push Workflow\n'));
+    await viewLogs();
+
+    const branch = git(['rev-parse', '--abbrev-ref', 'HEAD']).trim();
+    console.log(dim(`  📌 Current branch: ${cyan(branch)}\n`));
+
+    // 2. Wait for user to fix
+    const { ready } = await inquirer.prompt([{
+        type: 'list',
+        name: 'ready',
+        message: yellow('Have you fixed the CI issues?'),
+        choices: [
+            { name: `${green('✅')}  Yes, stage & re-push my changes`, value: 'yes' },
+            { name: `${yellow('📝')}  Yes, but let me write a new commit message`, value: 'new-msg' },
+            { name: `${dim('⬅')}   Cancel`, value: 'cancel' },
+        ]
+    }]);
+
+    if (ready === 'cancel') return;
+
+    const spinner = ora('Staging changes...').start();
+
+    try {
+        // 3. Stage everything
+        git(['add', '.'], { stdio: 'ignore' });
+
+        const status = git(['status', '--porcelain']);
+        if (!status.trim()) {
+            spinner.warn(yellow('No changes detected. Make sure you saved your files.'));
+            return;
+        }
+
+        if (ready === 'new-msg') {
+            spinner.stop();
+            const { msg } = await inquirer.prompt([{
+                type: 'input',
+                name: 'msg',
+                message: 'Commit message:',
+                default: 'fix: address CI failures'
+            }]);
+            execFileSync('git', ['commit', '-m', msg], { stdio: 'ignore' });
+            spinner.start('Pushing...');
+        } else {
+            // Amend the previous commit (cleaner history)
+            spinner.text = 'Amending previous commit...';
+            git(['commit', '--amend', '--no-edit'], { stdio: 'ignore' });
+        }
+
+        // 4. Force push
+        spinner.text = 'Force-pushing to origin...';
+        git(['push', 'origin', branch, '--force-with-lease'], { stdio: 'ignore' });
+        spinner.succeed(green('Changes pushed! CI will re-run automatically.'));
+
+        // 5. Wait a moment and re-check
+        console.log(dim('\n  ⏳ Waiting 10s for CI to pick up the new commit...\n'));
+        await new Promise(r => setTimeout(r, 10000));
+        await viewLogs();
+    } catch (e: any) {
+        spinner.fail(chalk.red(`Re-push failed: ${e.message}`));
+    }
+}
+
+/**
+ * Phase 12: Reply to Maintainer Comments
+ * Fetches PR review comments and lets the contributor reply interactively.
+ */
+export async function replyToComments() {
+    const inquirer = (await import('inquirer')).default;
+
+    const spinner = ora('Fetching PR comments...').start();
+    try {
+        const owner = getOwner();
+        const repo = getRepo();
+        const octokit = getOctokit();
+        const branch = git(['rev-parse', '--abbrev-ref', 'HEAD']).trim();
+        const myUser = await getAuthenticatedUser();
+
+        // Find our open PR for this branch
+        const { data: prs } = await octokit.pulls.list({
+            owner, repo, state: 'open', head: `${myUser}:${branch}`
+        });
+
+        if (prs.length === 0) {
+            spinner.fail('No open PR found for this branch.');
+            return;
+        }
+
+        const pr = prs[0];
+        spinner.text = `Fetching comments for PR #${pr.number}...`;
+
+        // Get issue comments (general PR comments)
+        const { data: issueComments } = await octokit.issues.listComments({
+            owner, repo, issue_number: pr.number
+        });
+
+        // Get review comments (inline code comments)
+        const { data: reviewComments } = await octokit.pulls.listReviewComments({
+            owner, repo, pull_number: pr.number
+        });
+
+        // Filter to show only comments from others (not our own)
+        const otherComments = [
+            ...issueComments.filter(c => c.user?.login !== myUser).map(c => ({
+                id: c.id,
+                type: 'issue' as const,
+                user: c.user?.login || 'unknown',
+                body: c.body || '',
+                created: c.created_at,
+                file: null as string | null,
+            })),
+            ...reviewComments.filter(c => c.user?.login !== myUser).map(c => ({
+                id: c.id,
+                type: 'review' as const,
+                user: c.user?.login || 'unknown',
+                body: c.body || '',
+                created: c.created_at,
+                file: c.path,
+            })),
+        ].sort((a, b) => new Date(b.created).getTime() - new Date(a.created).getTime());
+
+        spinner.stop();
+
+        if (otherComments.length === 0) {
+            console.log(green('\n  ✅ No comments from maintainers to reply to.\n'));
+            return;
+        }
+
+        console.log(chalk.bold(`\n  💬 ${otherComments.length} comment(s) on PR #${pr.number}: "${pr.title}"\n`));
+
+        // Show each comment and offer to reply
+        for (const comment of otherComments) {
+            const fileInfo = comment.file ? dim(` (${comment.file})`) : '';
+            console.log(`  ${cyan(`@${comment.user}`)}${fileInfo} — ${dim(new Date(comment.created).toLocaleDateString())}`);
+            console.log(`  ${white(comment.body.substring(0, 200))}${comment.body.length > 200 ? dim('...') : ''}\n`);
+
+            const { action } = await inquirer.prompt([{
+                type: 'list',
+                name: 'action',
+                message: `Reply to @${comment.user}?`,
+                choices: [
+                    { name: `${green('💬')}  Write a reply`, value: 'reply' },
+                    { name: `${dim('⏩')}  Skip`, value: 'skip' },
+                    { name: `${dim('⬅')}   Done reviewing`, value: 'done' },
+                ]
+            }]);
+
+            if (action === 'done') break;
+            if (action === 'skip') continue;
+
+            const { reply } = await inquirer.prompt([{
+                type: 'input',
+                name: 'reply',
+                message: 'Your reply:'
+            }]);
+
+            if (reply && reply.trim()) {
+                const replySpinner = ora('Posting reply...').start();
+                if (comment.type === 'review') {
+                    await octokit.pulls.createReplyForReviewComment({
+                        owner, repo,
+                        pull_number: pr.number,
+                        comment_id: comment.id,
+                        body: reply,
+                    });
+                } else {
+                    await octokit.issues.createComment({
+                        owner, repo,
+                        issue_number: pr.number,
+                        body: `> ${comment.body.split('\n')[0]}\n\n${reply}`,
+                    });
+                }
+                replySpinner.succeed(green('Reply posted!'));
+            }
+        }
+        console.log('');
+    } catch (e: any) {
+        spinner.fail(e.message);
+    }
+}

package/src/commands/gitlab-issues.ts

@@ -0,0 +1,87 @@
+// commands/gitlab-issues.ts — GitLab issue management for GitPadi
+
+import chalk from 'chalk';
+import ora from 'ora';
+import Table from 'cli-table3';
+import {
+    getNamespace, getProject, getFullProject, requireGitLabProject,
+    listGitLabIssues, createGitLabIssue, updateGitLabIssue, createGitLabIssueNote,
+    withGitLabRetry,
+} from '../core/gitlab.js';
+
+export async function listIssues(opts: { state?: string; limit?: number } = {}) {
+    requireGitLabProject();
+    const spinner = ora(`Fetching issues from ${chalk.cyan(getFullProject())}...`).start();
+    try {
+        const state = (opts.state === 'closed' ? 'closed' : opts.state === 'all' ? 'all' : 'opened') as 'opened' | 'closed' | 'all';
+        const issues = await withGitLabRetry(() =>
+            listGitLabIssues(getNamespace(), getProject(), { state, per_page: opts.limit || 50 })
+        );
+        spinner.stop();
+
+        if (!issues.length) { console.log(chalk.yellow('\n  No issues found.\n')); return; }
+
+        const table = new Table({
+            head: ['#', 'Title', 'Author', 'State', 'Labels'].map(h => chalk.cyan(h)),
+            style: { head: [], border: [] },
+        });
+
+        issues.forEach(issue => {
+            const stateLabel = issue.state === 'opened' ? chalk.green('open') : chalk.red('closed');
+            table.push([
+                `#${issue.iid}`,
+                issue.title.substring(0, 50),
+                `@${issue.author.username}`,
+                stateLabel,
+                issue.labels.slice(0, 3).join(', ') || '-',
+            ]);
+        });
+
+        console.log(`\n${chalk.bold(`📋 Issues — ${getFullProject()}`)} (${issues.length})\n`);
+        console.log(table.toString());
+        console.log('');
+    } catch (e: any) { spinner.fail(e.message); }
+}
+
+export async function createIssue(opts: { title: string; description?: string; labels?: string }) {
+    requireGitLabProject();
+    const spinner = ora('Creating issue...').start();
+    try {
+        const issue = await withGitLabRetry(() =>
+            createGitLabIssue(getNamespace(), getProject(), {
+                title: opts.title,
+                description: opts.description,
+                labels: opts.labels,
+            })
+        );
+        spinner.succeed(`Created issue ${chalk.green(`#${issue.iid}`)}: ${issue.title}`);
+        console.log(chalk.dim(`  ${issue.web_url}\n`));
+    } catch (e: any) { spinner.fail(e.message); }
+}
+
+export async function closeIssue(iid: number) {
+    requireGitLabProject();
+    const spinner = ora(`Closing issue #${iid}...`).start();
+    try {
+        await withGitLabRetry(() => updateGitLabIssue(getNamespace(), getProject(), iid, { state_event: 'close' }));
+        spinner.succeed(`Closed issue ${chalk.red(`#${iid}`)}`);
+    } catch (e: any) { spinner.fail(e.message); }
+}
+
+export async function reopenIssue(iid: number) {
+    requireGitLabProject();
+    const spinner = ora(`Reopening issue #${iid}...`).start();
+    try {
+        await withGitLabRetry(() => updateGitLabIssue(getNamespace(), getProject(), iid, { state_event: 'reopen' }));
+        spinner.succeed(`Reopened issue ${chalk.green(`#${iid}`)}`);
+    } catch (e: any) { spinner.fail(e.message); }
+}
+
+export async function commentOnIssue(iid: number, body: string) {
+    requireGitLabProject();
+    const spinner = ora(`Posting comment on issue #${iid}...`).start();
+    try {
+        await withGitLabRetry(() => createGitLabIssueNote(getNamespace(), getProject(), iid, body));
+        spinner.succeed(`Comment posted on issue #${iid}`);
+    } catch (e: any) { spinner.fail(e.message); }
+}