@oss-autopilot/core 0.41.0

package/dist/cli.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+/**
+ * OSS Autopilot CLI
+ * Entry point with commander for argument parsing
+ *
+ * Supports --json flag for structured output (used by Claude Code plugin)
+ *
+ * Performance: Command modules are lazy-loaded via dynamic import() so that
+ * only the invoked command's code is evaluated. The preAction hook uses an
+ * async token fetch to avoid blocking the event loop on `gh auth token`.
+ */
+export {};

package/dist/cli.js

@@ -0,0 +1,325 @@
+#!/usr/bin/env node
+/**
+ * OSS Autopilot CLI
+ * Entry point with commander for argument parsing
+ *
+ * Supports --json flag for structured output (used by Claude Code plugin)
+ *
+ * Performance: Command modules are lazy-loaded via dynamic import() so that
+ * only the invoked command's code is evaluated. The preAction hook uses an
+ * async token fetch to avoid blocking the event loop on `gh auth token`.
+ */
+import { Command } from 'commander';
+import { getGitHubTokenAsync, enableDebug, debug } from './core/index.js';
+const VERSION = (() => {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const fs = require('fs');
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const path = require('path');
+        const pkgPath = path.join(path.dirname(process.argv[1]), '..', 'package.json');
+        return JSON.parse(fs.readFileSync(pkgPath, 'utf-8')).version;
+    }
+    catch (_err) {
+        // package.json may not be readable in all bundle/install configurations — fall back to safe default
+        return '0.0.0';
+    }
+})();
+// Commands that skip the preAction GitHub token check.
+// startup handles auth internally (returns authError in JSON instead of process.exit).
+const LOCAL_ONLY_COMMANDS = [
+    'help',
+    'status',
+    'config',
+    'read',
+    'untrack',
+    'version',
+    'setup',
+    'checkSetup',
+    'dashboard',
+    'parse-issue-list',
+    'check-integration',
+    'local-repos',
+    'startup',
+    'shelve',
+    'unshelve',
+    'dismiss',
+    'undismiss',
+    'snooze',
+    'unsnooze',
+];
+const program = new Command();
+program
+    .name('oss-autopilot')
+    .description('AI-powered autopilot for managing open source contributions')
+    .version(VERSION)
+    .option('--debug', 'Enable debug logging');
+// Daily check command
+program
+    .command('daily')
+    .description('Run daily check on all tracked PRs')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    const { runDaily } = await import('./commands/daily.js');
+    await runDaily({ json: options.json });
+});
+// Status command
+program
+    .command('status')
+    .description('Show current status and stats')
+    .option('--json', 'Output as JSON')
+    .option('--offline', 'Use cached data only (no GitHub API calls)')
+    .action(async (options) => {
+    const { runStatus } = await import('./commands/status.js');
+    await runStatus({ json: options.json, offline: options.offline });
+});
+// Search command
+program
+    .command('search [count]')
+    .description('Search for new issues to work on')
+    .option('--json', 'Output as JSON')
+    .action(async (count, options) => {
+    const { runSearch } = await import('./commands/search.js');
+    await runSearch({ maxResults: parseInt(count) || 5, json: options.json });
+});
+// Vet command
+program
+    .command('vet <issue-url>')
+    .description('Vet a specific issue before working on it')
+    .option('--json', 'Output as JSON')
+    .action(async (issueUrl, options) => {
+    const { runVet } = await import('./commands/vet.js');
+    await runVet({ issueUrl, json: options.json });
+});
+// Track command
+program
+    .command('track <pr-url>')
+    .description('Add a PR to track')
+    .option('--json', 'Output as JSON')
+    .action(async (prUrl, options) => {
+    const { runTrack } = await import('./commands/track.js');
+    await runTrack({ prUrl, json: options.json });
+});
+// Untrack command
+program
+    .command('untrack <pr-url>')
+    .description('Stop tracking a PR')
+    .option('--json', 'Output as JSON')
+    .action(async (prUrl, options) => {
+    const { runUntrack } = await import('./commands/track.js');
+    await runUntrack({ prUrl, json: options.json });
+});
+// Read command (mark as read)
+program
+    .command('read [pr-url]')
+    .description('Mark PR comments as read')
+    .option('--all', 'Mark all PRs as read')
+    .option('--json', 'Output as JSON')
+    .action(async (prUrl, options) => {
+    const { runRead } = await import('./commands/read.js');
+    await runRead({ prUrl, all: options.all, json: options.json });
+});
+// Comments command
+program
+    .command('comments <pr-url>')
+    .description('Show all comments on a PR')
+    .option('--bots', 'Include bot comments')
+    .option('--json', 'Output as JSON')
+    .action(async (prUrl, options) => {
+    const { runComments } = await import('./commands/comments.js');
+    await runComments({ prUrl, showBots: options.bots, json: options.json });
+});
+// Post command
+program
+    .command('post <url> [message...]')
+    .description('Post a comment to a PR or issue')
+    .option('--stdin', 'Read message from stdin')
+    .option('--json', 'Output as JSON')
+    .action(async (url, messageParts, options) => {
+    const { runPost } = await import('./commands/comments.js');
+    const message = options.stdin ? undefined : messageParts.join(' ');
+    await runPost({ url, message, stdin: options.stdin, json: options.json });
+});
+// Claim command
+program
+    .command('claim <issue-url> [message...]')
+    .description('Claim an issue by posting a comment')
+    .option('--json', 'Output as JSON')
+    .action(async (issueUrl, messageParts, options) => {
+    const { runClaim } = await import('./commands/comments.js');
+    const message = messageParts.length > 0 ? messageParts.join(' ') : undefined;
+    await runClaim({ issueUrl, message, json: options.json });
+});
+// Config command
+program
+    .command('config [key] [value]')
+    .description('Show or update configuration')
+    .option('--json', 'Output as JSON')
+    .action(async (key, value, options) => {
+    const { runConfig } = await import('./commands/config.js');
+    await runConfig({ key, value, json: options.json });
+});
+// Init command
+program
+    .command('init <username>')
+    .description('Initialize with your GitHub username and import open PRs')
+    .option('--json', 'Output as JSON')
+    .action(async (username, options) => {
+    const { runInit } = await import('./commands/init.js');
+    await runInit({ username, json: options.json });
+});
+// Setup command
+program
+    .command('setup')
+    .description('Interactive setup / configuration')
+    .option('--reset', 'Re-run setup even if already complete')
+    .option('--set <settings...>', 'Set specific values (key=value)')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    const { runSetup } = await import('./commands/setup.js');
+    await runSetup({ reset: options.reset, set: options.set, json: options.json });
+});
+// Check setup command
+program
+    .command('checkSetup')
+    .description('Check if setup is complete')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    const { runCheckSetup } = await import('./commands/setup.js');
+    await runCheckSetup({ json: options.json });
+});
+// Dashboard command
+program
+    .command('dashboard')
+    .description('Generate HTML stats dashboard')
+    .option('--open', 'Open in browser')
+    .option('--json', 'Output as JSON')
+    .option('--offline', 'Use cached data only (no GitHub API calls)')
+    .action(async (options) => {
+    const { runDashboard } = await import('./commands/dashboard.js');
+    await runDashboard({ open: options.open, json: options.json, offline: options.offline });
+});
+// Parse issue list command (#82)
+program
+    .command('parse-issue-list <path>')
+    .description('Parse a markdown issue list into structured JSON')
+    .option('--json', 'Output as JSON')
+    .action(async (filePath, options) => {
+    const { runParseList } = await import('./commands/parse-list.js');
+    await runParseList({ filePath, json: options.json });
+});
+// Check integration command (#83)
+program
+    .command('check-integration')
+    .description('Detect new files not referenced by the codebase')
+    .option('--base <branch>', 'Base branch to compare against', 'main')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    const { runCheckIntegration } = await import('./commands/check-integration.js');
+    await runCheckIntegration({ base: options.base, json: options.json });
+});
+// Local repos command (#84)
+program
+    .command('local-repos')
+    .description('Scan filesystem for local git clones')
+    .option('--scan', 'Force re-scan (ignores cache)')
+    .option('--paths <dirs...>', 'Directories to scan')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    const { runLocalRepos } = await import('./commands/local-repos.js');
+    await runLocalRepos({ scan: options.scan, paths: options.paths, json: options.json });
+});
+// Startup command (combines auth, setup, daily, dashboard, issue list)
+program
+    .command('startup')
+    .description('Run all pre-flight checks and daily fetch in one call')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    const { runStartup } = await import('./commands/startup.js');
+    await runStartup({ json: options.json });
+});
+// Shelve command
+program
+    .command('shelve <pr-url>')
+    .description('Shelve a PR (exclude from capacity and actionable issues)')
+    .option('--json', 'Output as JSON')
+    .action(async (prUrl, options) => {
+    const { runShelve } = await import('./commands/shelve.js');
+    await runShelve({ prUrl, json: options.json });
+});
+// Unshelve command
+program
+    .command('unshelve <pr-url>')
+    .description('Unshelve a PR (include in capacity and actionable issues again)')
+    .option('--json', 'Output as JSON')
+    .action(async (prUrl, options) => {
+    const { runUnshelve } = await import('./commands/shelve.js');
+    await runUnshelve({ prUrl, json: options.json });
+});
+// Dismiss command
+program
+    .command('dismiss <issue-url>')
+    .description('Dismiss issue reply notifications (resurfaces on new activity)')
+    .option('--json', 'Output as JSON')
+    .action(async (issueUrl, options) => {
+    const { runDismiss } = await import('./commands/dismiss.js');
+    await runDismiss({ issueUrl, json: options.json });
+});
+// Undismiss command
+program
+    .command('undismiss <issue-url>')
+    .description('Undismiss an issue (re-enable reply notifications)')
+    .option('--json', 'Output as JSON')
+    .action(async (issueUrl, options) => {
+    const { runUndismiss } = await import('./commands/dismiss.js');
+    await runUndismiss({ issueUrl, json: options.json });
+});
+// Snooze command
+program
+    .command('snooze <pr-url>')
+    .description('Snooze CI failure notifications for a PR')
+    .requiredOption('--reason <reason>', 'Reason for snoozing (e.g., "upstream infrastructure issue")')
+    .option('--days <days>', 'Number of days to snooze (default: 7)', '7')
+    .option('--json', 'Output as JSON')
+    .action(async (prUrl, options) => {
+    const { runSnooze } = await import('./commands/snooze.js');
+    await runSnooze({ prUrl, reason: options.reason, days: parseInt(options.days, 10), json: options.json });
+});
+// Unsnooze command
+program
+    .command('unsnooze <pr-url>')
+    .description('Unsnooze a PR (re-enable CI failure notifications)')
+    .option('--json', 'Output as JSON')
+    .action(async (prUrl, options) => {
+    const { runUnsnooze } = await import('./commands/snooze.js');
+    await runUnsnooze({ prUrl, json: options.json });
+});
+// Validate GitHub token before running commands that need it
+program.hook('preAction', async (thisCommand, actionCommand) => {
+    // Enable debug logging if --debug flag is set
+    const globalOpts = thisCommand.opts();
+    if (globalOpts.debug) {
+        enableDebug();
+        debug('cli', `Running command: ${actionCommand.name()}`);
+    }
+    // actionCommand is the command being executed (e.g., 'status', 'daily')
+    const commandName = actionCommand.name();
+    if (!LOCAL_ONLY_COMMANDS.includes(commandName)) {
+        const token = await getGitHubTokenAsync();
+        if (!token) {
+            console.error('Error: GitHub authentication required.');
+            console.error('');
+            console.error('Option 1 (Recommended): Install and authenticate GitHub CLI');
+            console.error('  Install: https://cli.github.com/');
+            console.error('  Then run: gh auth login');
+            console.error('');
+            console.error('Option 2: Set GITHUB_TOKEN environment variable');
+            console.error('  export GITHUB_TOKEN="your-github-token-here"');
+            console.error('');
+            console.error('Then run your command again.');
+            process.exit(1);
+        }
+    }
+});
+// Parse and execute
+program.parse();

package/dist/commands/check-integration.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Check integration command (#83)
+ * Detects new files in the current branch that aren't referenced elsewhere
+ */
+interface CheckIntegrationOptions {
+    base: string;
+    json?: boolean;
+}
+export declare function runCheckIntegration(options: CheckIntegrationOptions): Promise<void>;
+export {};

package/dist/commands/check-integration.js

@@ -0,0 +1,192 @@
+/**
+ * Check integration command (#83)
+ * Detects new files in the current branch that aren't referenced elsewhere
+ */
+import * as path from 'path';
+import { execFileSync } from 'child_process';
+import { outputJson, outputJsonError } from '../formatters/json.js';
+import { debug } from '../core/index.js';
+/** File extensions we consider "code" that should be imported/referenced */
+const CODE_EXTENSIONS = new Set([
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.mjs',
+    '.cjs',
+    '.py',
+    '.rb',
+    '.go',
+    '.rs',
+    '.java',
+    '.kt',
+    '.vue',
+    '.svelte',
+]);
+/** Files that are typically entry points or config, not expected to be imported */
+const IGNORED_PATTERNS = [
+    /^\./, // dotfiles
+    /\.(test|spec|e2e)\.[^.]+$/, // test files
+    /\.(config|rc)\.[^.]+$/, // config files
+    /__tests__\//, // test directories
+    /\.d\.ts$/, // type declarations
+    /\.md$/, // documentation
+    /\.json$/, // json files
+    /\.ya?ml$/, // yaml files
+];
+/** Get the basename without extension for import matching (TS/JS) */
+function getImportName(filePath) {
+    const ext = path.extname(filePath);
+    const base = path.basename(filePath, ext);
+    // index files are imported by their directory name
+    if (base === 'index') {
+        return path.basename(path.dirname(filePath));
+    }
+    return base;
+}
+/** Suggest likely entry points for a new file based on its location */
+function suggestEntryPoints(newFile, existingFiles) {
+    const dir = path.dirname(newFile);
+    const suggestions = [];
+    // Look for index files in the same directory
+    for (const ext of ['.ts', '.tsx', '.js', '.jsx']) {
+        const indexFile = path.join(dir, `index${ext}`);
+        if (existingFiles.includes(indexFile)) {
+            suggestions.push(indexFile);
+        }
+    }
+    // Look for barrel/index in parent directory
+    const parentDir = path.dirname(dir);
+    for (const ext of ['.ts', '.tsx', '.js', '.jsx']) {
+        const parentIndex = path.join(parentDir, `index${ext}`);
+        if (existingFiles.includes(parentIndex)) {
+            suggestions.push(parentIndex);
+        }
+    }
+    return [...new Set(suggestions)];
+}
+export async function runCheckIntegration(options) {
+    const base = options.base;
+    // Get new files added in this branch vs base
+    let newFiles;
+    try {
+        const output = execFileSync('git', ['diff', '--name-only', '--diff-filter=A', `${base}...HEAD`], {
+            encoding: 'utf-8',
+            timeout: 10000,
+        }).trim();
+        newFiles = output ? output.split('\n').filter(Boolean) : [];
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (options.json) {
+            outputJsonError(`Failed to run git diff: ${msg}`);
+        }
+        else {
+            console.error(`Error: Failed to run git diff: ${msg}`);
+        }
+        process.exit(1);
+    }
+    // Filter to code files, excluding tests, configs, etc.
+    const codeFiles = newFiles.filter((f) => {
+        const ext = path.extname(f);
+        if (!CODE_EXTENSIONS.has(ext))
+            return false;
+        return !IGNORED_PATTERNS.some((p) => p.test(f));
+    });
+    if (codeFiles.length === 0) {
+        const result = { newFiles: [], unreferencedCount: 0 };
+        if (options.json) {
+            outputJson(result);
+        }
+        else {
+            console.log('\nNo new code files to check.');
+        }
+        return;
+    }
+    // Get all tracked files in the repo for reference checking
+    let allFiles;
+    try {
+        allFiles = execFileSync('git', ['ls-files'], {
+            encoding: 'utf-8',
+            timeout: 10000,
+        })
+            .trim()
+            .split('\n')
+            .filter(Boolean);
+    }
+    catch (err) {
+        // git ls-files failed (e.g. not a git repo) — proceed without reference list
+        debug('check-integration', 'git ls-files failed, reference checking will be skipped', err);
+        allFiles = [];
+    }
+    // For each new file, search for references in the repo
+    const results = [];
+    for (const newFile of codeFiles) {
+        const importName = getImportName(newFile);
+        const fileWithoutExt = newFile.replace(/\.[^.]+$/, '');
+        // Search for references using git grep (fast, respects .gitignore)
+        let referencedBy = [];
+        // Search for: import from './filename', require('./filename'), or just the filename stem
+        const patterns = [
+            importName, // bare name (covers most import patterns)
+        ];
+        // Also search for path-based imports (relative path without extension)
+        if (fileWithoutExt.includes('/')) {
+            patterns.push(fileWithoutExt);
+        }
+        for (const pattern of patterns) {
+            try {
+                const grepOutput = execFileSync('git', ['grep', '-l', '--', pattern], {
+                    encoding: 'utf-8',
+                    timeout: 10000,
+                }).trim();
+                if (grepOutput) {
+                    const matches = grepOutput.split('\n').filter((f) => f !== newFile);
+                    referencedBy.push(...matches);
+                }
+            }
+            catch (error) {
+                // git grep exit code 1 = no matches (expected), exit code 2+ = real error
+                const exitCode = error && typeof error === 'object' && 'status' in error ? error.status : null;
+                if (exitCode !== null && exitCode !== 1) {
+                    const msg = error instanceof Error ? error.message : String(error);
+                    console.error(`Warning: git grep failed for "${pattern}": ${msg}`);
+                }
+            }
+        }
+        // Deduplicate
+        referencedBy = [...new Set(referencedBy)];
+        const isIntegrated = referencedBy.length > 0;
+        const info = {
+            path: newFile,
+            referencedBy,
+            isIntegrated,
+        };
+        if (!isIntegrated) {
+            info.suggestedEntryPoints = suggestEntryPoints(newFile, allFiles);
+        }
+        results.push(info);
+    }
+    const unreferencedCount = results.filter((r) => !r.isIntegrated).length;
+    const output = { newFiles: results, unreferencedCount };
+    if (options.json) {
+        outputJson(output);
+    }
+    else {
+        console.log(`\n🔍 Integration Check (base: ${base})\n`);
+        console.log(`New files: ${results.length} | Unreferenced: ${unreferencedCount}\n`);
+        for (const file of results) {
+            const status = file.isIntegrated ? '✅' : '⚠️';
+            console.log(`${status} ${file.path}`);
+            if (file.isIntegrated) {
+                console.log(`   Referenced by: ${file.referencedBy.join(', ')}`);
+            }
+            else {
+                console.log('   Not referenced by any file');
+                if (file.suggestedEntryPoints && file.suggestedEntryPoints.length > 0) {
+                    console.log(`   Suggested entry points: ${file.suggestedEntryPoints.join(', ')}`);
+                }
+            }
+        }
+    }
+}

package/dist/commands/comments.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Comments, Post, and Claim commands
+ * Handles GitHub comment interactions
+ */
+interface CommentsOptions {
+    prUrl: string;
+    showBots?: boolean;
+    json?: boolean;
+}
+interface PostOptions {
+    url: string;
+    message?: string;
+    stdin?: boolean;
+    json?: boolean;
+}
+interface ClaimOptions {
+    issueUrl: string;
+    message?: string;
+    json?: boolean;
+}
+export declare function runComments(options: CommentsOptions): Promise<void>;
+export declare function runPost(options: PostOptions): Promise<void>;
+export declare function runClaim(options: ClaimOptions): Promise<void>;
+export {};