gitpadi 2.0.0 → 2.0.1

package/src/cli.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env npx tsx
+#!/usr/bin/env node
 // ═══════════════════════════════════════════════════════════════════════
 //  GitPadi v2.0 — Your AI-Powered GitHub Management Terminal
 //  "Built different. Run different."
@@ -11,7 +11,8 @@ import gradient from 'gradient-string';
 import figlet from 'figlet';
 import boxen from 'boxen';
 import { createSpinner } from 'nanospinner';
-import { initGitHub, setRepo, getOwner, getRepo, getOctokit } from './core/github.js';
+import { Octokit } from '@octokit/rest';
+import { initGitHub, setRepo, getOwner, getRepo, getOctokit, loadConfig, saveConfig, getToken } from './core/github.js';
 
 import * as issues from './commands/issues.js';
 import * as prs from './commands/prs.js';
@@ -124,17 +125,27 @@ async function bootSequence() {
 
 // ── Onboarding ─────────────────────────────────────────────────────────
 async function onboarding() {
-    const savedToken = process.env.GITHUB_TOKEN || process.env.GITPADI_TOKEN;
-    const savedOwner = process.env.GITHUB_OWNER;
-    const savedRepo = process.env.GITHUB_REPO;
+    // Force a fresh load from config/env
+    initGitHub();
 
-    if (savedToken && savedOwner && savedRepo) {
-        initGitHub(savedToken, savedOwner, savedRepo);
+    let token = getToken();
+    let owner = getOwner();
+    let repo = getRepo();
+
+    // If everything is already set (likely via env or previously saved config), skip
+    if (token && owner && repo) {
         const spinner = createSpinner(dim('Authenticating...')).start();
-        await sleep(600);
-        spinner.success({ text: green(`Connected to ${cyan(`${savedOwner}/${savedRepo}`)}`) });
-        console.log('');
-        return;
+        try {
+            const octokit = getOctokit();
+            await octokit.users.getAuthenticated();
+            spinner.success({ text: green(`Authenticated & targeting ${cyan(`${owner}/${repo}`)}`) });
+            console.log('');
+            return;
+        } catch {
+            spinner.error({ text: red('Saved session invalid. Re-authenticating...') });
+            // Clear and continue to prompt
+            token = '';
+        }
     }
 
     console.log(neon('  ⚡ First-time setup — let\'s connect you to GitHub.\n'));
@@ -145,43 +156,59 @@ async function onboarding() {
             name: 'token',
             message: magenta('🔑 GitHub Token') + dim(' (ghp_xxx):'),
             mask: '•',
-            validate: (v: string) => v.startsWith('ghp_') || v.startsWith('github_pat_') ? true : 'Token should start with ghp_ or github_pat_',
-            when: !savedToken,
+            validate: async (v: string) => {
+                if (!v.startsWith('ghp_') && !v.startsWith('github_pat_')) {
+                    return 'Token should start with ghp_ or github_pat_';
+                }
+                const spinner = createSpinner(dim('Validating token...')).start();
+                try {
+                    const tempOctokit = new Octokit({ auth: v });
+                    await tempOctokit.users.getAuthenticated();
+                    spinner.success({ text: green('Token valid!') });
+                    return true;
+                } catch {
+                    spinner.error({ text: red('Invalid token - GitHub rejected it.') });
+                    return 'Invalid token';
+                }
+            },
+            when: !token,
         },
         {
             type: 'input',
             name: 'owner',
             message: cyan('👤 GitHub Owner/Org:'),
-            default: savedOwner || '',
+            default: owner || '',
             validate: (v: string) => v.length > 0 || 'Required',
-            when: !savedOwner,
+            when: !owner,
         },
         {
             type: 'input',
             name: 'repo',
             message: cyan('📦 Repository name:'),
-            default: savedRepo || '',
+            default: repo || '',
             validate: (v: string) => v.length > 0 || 'Required',
-            when: !savedRepo,
+            when: !repo,
         },
     ]);
 
-    const token = answers.token || savedToken;
-    const owner = answers.owner || savedOwner;
-    const repo = answers.repo || savedRepo;
+    const finalToken = answers.token || token;
+    const finalOwner = answers.owner || owner;
+    const finalRepo = answers.repo || repo;
 
-    initGitHub(token, owner, repo);
+    initGitHub(finalToken, finalOwner, finalRepo);
+    saveConfig({ token: finalToken, owner: finalOwner, repo: finalRepo });
 
     const spinner = createSpinner(dim('Connecting to GitHub...')).start();
-    await sleep(800);
-    spinner.success({ text: green(`Locked in → ${cyan(`${owner}/${repo}`)}`) });
+    await sleep(400);
+    spinner.success({ text: green(`Locked in → ${cyan(`${finalOwner}/${finalRepo}`)}`) });
 
     console.log('');
     console.log(boxen(
-        dim('💡 Pro tip: Set these to skip setup next time:\n\n') +
+        dim('💡 Session saved to ~/.gitpadi/config.json\n\n') +
+        dim('Set environment variables to override:\n') +
         yellow('  export GITHUB_TOKEN=ghp_xxx\n') +
-        yellow('  export GITHUB_OWNER=' + owner + '\n') +
-        yellow('  export GITHUB_REPO=' + repo),
+        yellow('  export GITHUB_OWNER=' + finalOwner + '\n') +
+        yellow('  export GITHUB_REPO=' + finalRepo),
         { padding: 1, borderColor: 'yellow', dimBorder: true, borderStyle: 'round' }
     ));
     console.log('');
@@ -267,7 +294,7 @@ async function issueMenu() {
             new inquirer.Separator(dim('  ─────────────────────────────')),
             { name: `  ${green('▸')} List open issues`, value: 'list' },
             { name: `  ${green('▸')} Create single issue`, value: 'create' },
-            { name: `  ${green('▸')} Bulk create from JSON`, value: 'bulk' },
+            { name: `  ${magenta('▸')} Bulk create from JSON file`, value: 'bulk' },
             { name: `  ${red('▸')} Close issue`, value: 'close' },
             { name: `  ${green('▸')} Reopen issue`, value: 'reopen' },
             { name: `  ${red('▸')} Delete (close & lock)`, value: 'delete' },
@@ -284,18 +311,19 @@ async function issueMenu() {
         const opts = await ask([
             { type: 'list', name: 'state', message: 'State:', choices: ['open', 'closed', 'all'], default: 'open' },
             { type: 'input', name: 'labels', message: dim('Filter by labels (optional, q=back):'), default: '' },
+            { type: 'input', name: 'limit', message: dim('Max results:'), default: '50' },
         ]);
-        await issues.listIssues({ state: opts.state, labels: opts.labels || undefined });
+        await issues.listIssues({ state: opts.state, labels: opts.labels || undefined, limit: parseInt(opts.limit) });
     } else if (action === 'create') {
         const a = await ask([
-            { type: 'input', name: 'title', message: yellow('Issue title') + dim(' (q=back):') },
-            { type: 'editor', name: 'body', message: 'Issue body (opens editor):' },
+            { type: 'input', name: 'title', message: yellow('Issue title'), validate: (v: string) => v.length > 0 || 'Required' },
+            { type: 'input', name: 'body', message: dim('Issue body (optional):'), default: '' },
             { type: 'input', name: 'labels', message: dim('Labels (comma-separated):'), default: '' },
         ]);
         await issues.createIssue(a);
     } else if (action === 'bulk') {
         const a = await ask([
-            { type: 'input', name: 'file', message: yellow('📁 Path to issues JSON') + dim(' (q=back):') },
+            { type: 'input', name: 'file', message: yellow('📁 Path to issues JSON file') + dim(' (q=back):') },
             { type: 'confirm', name: 'dryRun', message: 'Dry run first?', default: true },
             { type: 'number', name: 'start', message: dim('Start index:'), default: 1 },
             { type: 'number', name: 'end', message: dim('End index:'), default: 999 },
@@ -416,8 +444,11 @@ async function prMenu() {
     if (action === 'back') return;
 
     if (action === 'list') {
-        const { state } = await inquirer.prompt([{ type: 'list', name: 'state', message: 'State:', choices: ['open', 'closed', 'all'] }]);
-        await prs.listPRs({ state });
+        const a = await ask([
+            { type: 'list', name: 'state', message: 'State:', choices: ['open', 'closed', 'all'], default: 'open' },
+            { type: 'input', name: 'limit', message: dim('Max results:'), default: '50' },
+        ]);
+        await prs.listPRs({ state: a.state, limit: parseInt(a.limit) });
     } else if (action === 'merge' || action === 'force-merge') {
         const a = await ask([
             { type: 'input', name: 'n', message: yellow('PR #') + dim(' (q=back):') },
@@ -459,8 +490,11 @@ async function repoMenu() {
     if (action === 'back') return;
 
     if (action === 'list') {
-        const { org } = await ask([{ type: 'input', name: 'org', message: cyan('Org (blank for yours, q=back):'), default: '' }]);
-        await repos.listRepos({ org: org || undefined });
+        const a = await ask([
+            { type: 'input', name: 'org', message: cyan('Org (blank for yours, q=back):'), default: '' },
+            { type: 'input', name: 'limit', message: dim('Max results:'), default: '50' },
+        ]);
+        await repos.listRepos({ org: a.org || undefined, limit: parseInt(a.limit) });
     } else if (action === 'create') {
         const a = await ask([
             { type: 'input', name: 'name', message: yellow('📦 Repo name') + dim(' (q=back):') },
@@ -521,7 +555,8 @@ async function contributorMenu() {
         const { n } = await ask([{ type: 'input', name: 'n', message: yellow('Issue #') + dim(' (q=back):') }]);
         await contributors.rankApplicants(parseInt(n));
     } else {
-        await contributors.listContributors({});
+        const a = await ask([{ type: 'input', name: 'limit', message: dim('Max results (q=back):'), default: '50' }]);
+        await contributors.listContributors({ limit: parseInt(a.limit) });
     }
 }
 
@@ -548,7 +583,8 @@ async function releaseMenu() {
         ]);
         await releases.createRelease(a.tag, { name: a.name || a.tag, draft: a.draft, prerelease: a.prerelease });
     } else {
-        await releases.listReleases({});
+        const a = await ask([{ type: 'input', name: 'limit', message: dim('Max results (q=back):'), default: '50' }]);
+        await releases.listReleases({ limit: parseInt(a.limit) });
     }
 }
 
@@ -569,7 +605,7 @@ function setupCommander(): Command {
 
     // Issues
     const i = program.command('issues').description('📋 Manage issues');
-    i.command('list').option('-s, --state <s>', '', 'open').option('-l, --labels <l>').option('-n, --limit <n>', '', '25')
+    i.command('list').option('-s, --state <s>', '', 'open').option('-l, --labels <l>').option('-n, --limit <n>', '', '50')
         .action((o) => issues.listIssues({ state: o.state, labels: o.labels, limit: parseInt(o.limit) }));
     i.command('create').requiredOption('-t, --title <t>').option('-b, --body <b>').option('-l, --labels <l>')
         .action((o) => issues.createIssue(o));
@@ -585,7 +621,7 @@ function setupCommander(): Command {
 
     // PRs
     const p = program.command('prs').description('🔀 Manage pull requests');
-    p.command('list').option('-s, --state <s>', '', 'open').option('-n, --limit <n>', '', '25')
+    p.command('list').option('-s, --state <s>', '', 'open').option('-n, --limit <n>', '', '50')
         .action((o) => prs.listPRs({ state: o.state, limit: parseInt(o.limit) }));
     p.command('merge <n>').option('-m, --method <m>', '', 'squash').option('--message <msg>').option('-f, --force', 'Skip CI checks')
         .action((n, o) => prs.mergePR(parseInt(n), o));
@@ -596,7 +632,7 @@ function setupCommander(): Command {
 
     // Repos
     const r = program.command('repo').description('📦 Manage repositories');
-    r.command('list').option('-o, --org <o>').option('-n, --limit <n>', '', '25')
+    r.command('list').option('-o, --org <o>').option('-n, --limit <n>', '', '50')
         .action((o) => repos.listRepos({ org: o.org, limit: parseInt(o.limit) }));
     r.command('create <name>').option('-o, --org <o>').option('-p, --private').option('-d, --description <d>')
         .action((n, o) => repos.createRepo(n, o));
@@ -609,13 +645,13 @@ function setupCommander(): Command {
     const c = program.command('contributors').description('🏆 Manage contributors');
     c.command('score <user>').action((u) => contributors.scoreUser(u));
     c.command('rank <issue>').action((n) => contributors.rankApplicants(parseInt(n)));
-    c.command('list').option('-n, --limit <n>', '', '25').action((o) => contributors.listContributors({ limit: parseInt(o.limit) }));
+    c.command('list').option('-n, --limit <n>', '', '50').action((o) => contributors.listContributors({ limit: parseInt(o.limit) }));
 
     // Releases
     const rel = program.command('release').description('🚀 Manage releases');
     rel.command('create <tag>').option('-n, --name <n>').option('-b, --body <b>').option('-d, --draft').option('-p, --prerelease').option('--no-generate')
         .action((t, o) => releases.createRelease(t, o));
-    rel.command('list').option('-n, --limit <n>', '', '10').action((o) => releases.listReleases({ limit: parseInt(o.limit) }));
+    rel.command('list').option('-n, --limit <n>', '', '50').action((o) => releases.listReleases({ limit: parseInt(o.limit) }));
 
     return program;
 }

package/src/commands/contributors.ts

@@ -94,7 +94,7 @@ export async function listContributors(opts: { limit?: number }) {
 
     try {
         const { data } = await getOctokit().repos.listContributors({
-            owner: getOwner(), repo: getRepo(), per_page: opts.limit || 25,
+            owner: getOwner(), repo: getRepo(), per_page: opts.limit || 50,
         });
         spinner.stop();
 

package/src/commands/issues.ts

@@ -18,7 +18,7 @@ export async function listIssues(opts: { state?: string; labels?: string; limit?
             owner: getOwner(), repo: getRepo(),
             state: (opts.state as 'open' | 'closed' | 'all') || 'open',
             labels: opts.labels || undefined,
-            per_page: opts.limit || 25,
+            per_page: opts.limit || 50,
         });
 
         // Filter out PRs (GitHub API returns PRs in issues endpoint)

package/src/commands/prs.ts

@@ -13,7 +13,7 @@ export async function listPRs(opts: { state?: string; limit?: number }) {
         const { data: prs } = await getOctokit().pulls.list({
             owner: getOwner(), repo: getRepo(),
             state: (opts.state as 'open' | 'closed' | 'all') || 'open',
-            per_page: opts.limit || 25,
+            per_page: opts.limit || 50,
         });
 
         spinner.stop();

package/src/commands/releases.ts

@@ -31,7 +31,7 @@ export async function listReleases(opts: { limit?: number }) {
 
     try {
         const { data } = await getOctokit().repos.listReleases({
-            owner: getOwner(), repo: getRepo(), per_page: opts.limit || 10,
+            owner: getOwner(), repo: getRepo(), per_page: opts.limit || 50,
         });
         spinner.stop();
 

package/src/commands/repos.ts

@@ -100,9 +100,9 @@ export async function listRepos(opts: { org?: string; limit?: number }) {
     try {
         let repos: any[];
         if (opts.org) {
-            ({ data: repos } = await octokit.repos.listForOrg({ org: opts.org, per_page: opts.limit || 25, sort: 'updated' }));
+            ({ data: repos } = await octokit.repos.listForOrg({ org: opts.org, per_page: opts.limit || 50, sort: 'updated' }));
         } else {
-            ({ data: repos } = await octokit.repos.listForAuthenticatedUser({ per_page: opts.limit || 25, sort: 'updated' }));
+            ({ data: repos } = await octokit.repos.listForAuthenticatedUser({ per_page: opts.limit || 50, sort: 'updated' }));
         }
 
         spinner.stop();

package/src/core/github.ts

@@ -1,36 +1,68 @@
-// core/github.ts — Shared Octokit client + auth for GitPadi
-
 import { Octokit } from '@octokit/rest';
 import chalk from 'chalk';
+import * as fs from 'fs';
+import * as path from 'path';
+import os from 'node:os';
+
+
+const CONFIG_DIR = path.join(os.homedir(), '.gitpadi');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
 
 let _octokit: Octokit | null = null;
 let _owner: string = '';
 let _repo: string = '';
+let _token: string = '';
 
-export function initGitHub(token?: string, owner?: string, repo?: string): void {
-    const t = token || process.env.GITHUB_TOKEN || process.env.GITPADI_TOKEN || '';
-    if (!t) {
-        console.error(chalk.red('\n❌ GitHub token required.'));
-        console.error(chalk.dim('   Set it: export GITHUB_TOKEN=ghp_xxx'));
-        console.error(chalk.dim('   Or:     export GITPADI_TOKEN=ghp_xxx\n'));
-        process.exit(1);
+export interface GitPadiConfig {
+    token: string;
+    owner: string;
+    repo: string;
+}
+
+export function loadConfig(): GitPadiConfig | null {
+    if (!fs.existsSync(CONFIG_FILE)) return null;
+    try {
+        return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+    } catch {
+        return null;
     }
+}
 
-    _octokit = new Octokit({ auth: t });
-    _owner = owner || process.env.GITHUB_OWNER || process.env.GITHUB_REPOSITORY?.split('/')[0] || '';
-    _repo = repo || process.env.GITHUB_REPO || process.env.GITHUB_REPOSITORY?.split('/')[1] || '';
+export function saveConfig(config: GitPadiConfig): void {
+    if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+export function initGitHub(token?: string, owner?: string, repo?: string): void {
+    const config = loadConfig();
+
+    _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] || '';
+
+    if (_token) {
+        _octokit = new Octokit({ auth: _token });
+    }
 }
 
 export function getOctokit(): Octokit {
     if (!_octokit) {
-        initGitHub();
+        throw new Error('GitHub client not initialized. Call initGitHub() first.');
     }
-    return _octokit!;
+    return _octokit;
 }
 
 export function getOwner(): string { return _owner; }
 export function getRepo(): string { return _repo; }
-export function setRepo(owner: string, repo: string): void { _owner = owner; _repo = repo; }
+export function getToken(): string { return _token; }
+export function setRepo(owner: string, repo: string): void {
+    _owner = owner;
+    _repo = repo;
+    // If we have a token, PERSIST the new repo selection
+    if (_token) {
+        saveConfig({ token: _token, owner, repo });
+    }
+}
 export function getFullRepo(): string { return `${_owner}/${_repo}`; }
 
 export function requireRepo(): void {

package/src/create-issues.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env tsx
+#!/usr/bin/env node
 // create-issues.ts — Generic issue creator from JSON data file
 //
 // Usage via GitHub Action:

package/src/pr-review.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env tsx
+#!/usr/bin/env node
 // pr-review.ts — Generic PR review agent for any repository
 //
 // Checks: linked issues, PR size, file scope, test coverage, commit messages, sensitive files