gitpadi 2.0.1 → 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/issues.js

@@ -60,6 +60,42 @@ export async function createIssue(opts) {
         spinner.fail(`Failed: ${e.message}`);
     }
 }
+/**
+ * Parse a markdown file into issues.
+ * Format:
+ *   ## Issue Title
+ *   **Labels:** bug, frontend
+ *   Body text here...
+ */
+function parseMarkdownIssues(content) {
+    const issues = [];
+    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 = [];
+        const bodyLines = [];
+        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, opts) {
     requireRepo();
     const resolved = path.resolve(filePath);
@@ -67,20 +103,48 @@ export async function createIssuesFromFile(filePath, opts) {
         console.error(chalk.red(`\n❌ File not found: ${resolved}\n`));
         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;
+    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) => 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`));
+    console.log(chalk.dim(`  Repo:   ${getFullRepo()}`));
+    console.log(chalk.dim(`  File:   ${filePath} (${detectedFormat})`));
+    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) => {
             console.log(`  ${chalk.dim(`#${String(i.number).padStart(2, '0')}`)}  ${i.title}`);
-            console.log(chalk.dim(`       [${i.labels.join(', ')}]`));
+            console.log(chalk.dim(`       [${(i.labels || []).join(', ')}]`));
+            if (i.body)
+                console.log(chalk.dim(`       ${i.body.substring(0, 80)}...`));
         });
         console.log(chalk.green(`\n✅ Dry run: ${filtered.length} issues would be created.\n`));
         return;
@@ -88,7 +152,7 @@ export async function createIssuesFromFile(filePath, opts) {
     const octokit = getOctokit();
     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/dist/commands/repos.js

@@ -51,9 +51,11 @@ export async function cloneRepo(name, opts) {
     try {
         execSync(`git clone ${url} ${dir}`, { stdio: 'pipe' });
         spinner.succeed(`Cloned to ${chalk.green(`./${dir}`)}`);
+        return true;
     }
     catch (e) {
         spinner.fail(`Clone failed: ${e.message}`);
+        return false;
     }
 }
 export async function repoInfo(name, opts) {
@@ -67,9 +69,11 @@ export async function repoInfo(name, opts) {
         table.push({ [chalk.cyan('Description')]: repo.description || chalk.dim('none') }, { [chalk.cyan('Stars')]: `⭐ ${repo.stargazers_count}` }, { [chalk.cyan('Forks')]: `🍴 ${repo.forks_count}` }, { [chalk.cyan('Issues')]: `📋 ${repo.open_issues_count} open` }, { [chalk.cyan('Language')]: repo.language || chalk.dim('none') }, { [chalk.cyan('Visibility')]: repo.private ? chalk.yellow('Private') : chalk.green('Public') }, { [chalk.cyan('Default Branch')]: repo.default_branch }, { [chalk.cyan('Created')]: new Date(repo.created_at).toLocaleDateString() }, { [chalk.cyan('URL')]: repo.html_url });
         console.log(table.toString());
         console.log('');
+        return repo;
     }
     catch (e) {
         spinner.fail(e.message);
+        return null;
     }
 }
 export async function setTopics(name, topics, opts) {
@@ -84,35 +88,41 @@ export async function setTopics(name, topics, opts) {
     }
 }
 export async function listRepos(opts) {
-    const spinner = ora('Fetching repos...').start();
+    const spinner = !opts.silent ? ora('Fetching repos...').start() : null;
     const octokit = getOctokit();
     try {
         let repos;
         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();
-        const table = new Table({
-            head: ['Name', 'Stars', 'Language', 'Visibility', 'Updated'].map((h) => chalk.cyan(h)),
-            style: { head: [], border: [] },
-        });
-        repos.forEach((r) => {
-            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('');
+        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) => {
+                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('');
+        }
+        return repos;
     }
     catch (e) {
-        spinner.fail(e.message);
+        if (spinner)
+            spinner.fail(e.message);
+        return [];
     }
 }

package/dist/core/github.js

@@ -3,6 +3,7 @@ import chalk from 'chalk';
 import * as fs from 'fs';
 import * as path from 'path';
 import os from 'node:os';
+import { execSync } from 'child_process';
 const CONFIG_DIR = path.join(os.homedir(), '.gitpadi');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
 let _octokit = null;
@@ -24,11 +25,29 @@ export function saveConfig(config) {
         fs.mkdirSync(CONFIG_DIR, { recursive: true });
     fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
 }
+/**
+ * Attempts to detect owner/repo from local git remotes
+ */
+export function detectLocalRepo() {
+    try {
+        const remotes = execSync('git remote -v', { encoding: 'utf-8', stdio: 'pipe' });
+        const match = remotes.match(/github\.com[:/]([^/]+)\/([^/.]+)(?:\.git)?/);
+        if (match) {
+            return { owner: match[1], repo: match[2] };
+        }
+    }
+    catch {
+        // Not a git repo or git not found
+    }
+    return null;
+}
 export function initGitHub(token, owner, repo) {
     const config = loadConfig();
+    const detected = detectLocalRepo();
     _token = token || process.env.GITHUB_TOKEN || process.env.GITPADI_TOKEN || config?.token || '';
-    _owner = owner || process.env.GITHUB_OWNER || config?.owner || process.env.GITHUB_REPOSITORY?.split('/')[0] || '';
-    _repo = repo || process.env.GITHUB_REPO || config?.repo || process.env.GITHUB_REPOSITORY?.split('/')[1] || '';
+    // Priority: Explicit > Env > Config > Local Git detection
+    _owner = owner || process.env.GITHUB_OWNER || config?.owner || detected?.owner || process.env.GITHUB_REPOSITORY?.split('/')[0] || '';
+    _repo = repo || process.env.GITHUB_REPO || config?.repo || detected?.repo || process.env.GITHUB_REPOSITORY?.split('/')[1] || '';
     if (_token) {
         _octokit = new Octokit({ auth: _token });
     }
@@ -59,3 +78,29 @@ export function requireRepo() {
         process.exit(1);
     }
 }
+/**
+ * ── Phase 1: Contributor Support Helpers ──
+ */
+export async function getAuthenticatedUser() {
+    const { data } = await getOctokit().users.getAuthenticated();
+    return data.login;
+}
+export async function forkRepo(owner, repo) {
+    const octokit = getOctokit();
+    const { data } = await octokit.repos.createFork({ owner, repo });
+    return data.full_name; // e.g. "myuser/original-repo"
+}
+export async function getRepoDetails(owner, repo) {
+    const { data } = await getOctokit().repos.get({ owner, repo });
+    return data;
+}
+export async function getLatestCheckRuns(owner, repo, ref) {
+    const octokit = getOctokit();
+    const { data: checks } = await octokit.checks.listForRef({ owner, repo, ref });
+    const { data: status } = await octokit.repos.getCombinedStatusForRef({ owner, repo, ref });
+    return {
+        checkRuns: checks.check_runs,
+        combinedState: status.state, // 'success', 'failure', 'pending'
+        statuses: status.statuses
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "gitpadi",
-    "version": "2.0.1",
+    "version": "2.0.2",
     "description": "🤖 GitPadi — Your AI-powered GitHub management CLI. Create repos, manage issues & PRs, score contributors, and automate everything.",
     "type": "module",
     "bin": {