gitpadi 2.0.6 → 2.1.1

package/dist/commands/contribute.js

@@ -1,7 +1,7 @@
 // commands/contribute.ts — Contributor workflow for GitPadi
 import chalk from 'chalk';
 import ora from 'ora';
-import { execSync } from 'child_process';
+import { execFileSync } from 'child_process';
 import * as fs from 'fs';
 import boxen from 'boxen';
 import { getOctokit, getOwner, getRepo, forkRepo, getAuthenticatedUser, getLatestCheckRuns, setRepo } from '../core/github.js';
@@ -19,7 +19,7 @@ function parseTarget(input) {
     if (match) {
         return {
             owner: match[1],
-            repo: match[2],
+            repo: match[2].replace(/\.git$/, ''),
             issue: match[4] ? parseInt(match[4]) : undefined
         };
     }
@@ -29,6 +29,14 @@ function parseTarget(input) {
     }
     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, opts = {}) {
+    return execFileSync('git', args, {
+        encoding: 'utf-8',
+        stdio: opts.stdio ?? 'pipe',
+        cwd: opts.cwd,
+    });
+}
 /**
  * Phase 2: Fork & Clone Workflow (The "Start" Command)
  */
@@ -41,6 +49,8 @@ export async function forkAndClone(target) {
         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) {
         spinner.fail(e.message);
@@ -66,7 +76,7 @@ export async function forkAndClone(target) {
         // 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;
         }
@@ -78,35 +88,52 @@ export async function forkAndClone(target) {
             setRepo(owner, repo);
             // Ensure upstream remote exists
             try {
-                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' });
             }
             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();
             // 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) {
+                            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}`));
+                            }
+                        }
+                    }
                 }
             }
             console.log(green('\n✨ Workspace ready!'));
@@ -121,26 +148,32 @@ export async function forkAndClone(target) {
             }]);
         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) {
-        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
     setRepo(owner, repo);
@@ -161,15 +194,15 @@ export async function forkAndClone(target) {
 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';
@@ -193,14 +226,14 @@ 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 {
@@ -211,7 +244,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 {
@@ -234,7 +267,7 @@ export async function submitPR(opts) {
     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;
         if (!linkedIssue) {
@@ -243,46 +276,39 @@ export async function submitPR(opts) {
                 linkedIssue = parseInt(match[1]);
         }
         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) {
-            // 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');
         // 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';
@@ -309,7 +335,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();
         if (checkRuns.length === 0) {
@@ -330,3 +356,171 @@ 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) {
+        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',
+                user: c.user?.login || 'unknown',
+                body: c.body || '',
+                created: c.created_at,
+                file: null,
+            })),
+            ...reviewComments.filter(c => c.user?.login !== myUser).map(c => ({
+                id: c.id,
+                type: 'review',
+                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) {
+        spinner.fail(e.message);
+    }
+}

package/dist/commands/gitlab-issues.js

@@ -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 = {}) {
+    requireGitLabProject();
+    const spinner = ora(`Fetching issues from ${chalk.cyan(getFullProject())}...`).start();
+    try {
+        const state = (opts.state === 'closed' ? 'closed' : opts.state === 'all' ? 'all' : 'opened');
+        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) {
+        spinner.fail(e.message);
+    }
+}
+export async function createIssue(opts) {
+    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) {
+        spinner.fail(e.message);
+    }
+}
+export async function closeIssue(iid) {
+    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) {
+        spinner.fail(e.message);
+    }
+}
+export async function reopenIssue(iid) {
+    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) {
+        spinner.fail(e.message);
+    }
+}
+export async function commentOnIssue(iid, body) {
+    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) {
+        spinner.fail(e.message);
+    }
+}