@oss-autopilot/core 0.41.0

package/dist/commands/dashboard.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Dashboard command — thin orchestrator.
+ * Coordinates data fetching, template generation, and file output.
+ * v2: Fetches fresh data from GitHub if token available, otherwise uses cached lastDigest.
+ */
+interface DashboardOptions {
+    open?: boolean;
+    json?: boolean;
+    offline?: boolean;
+}
+export declare function runDashboard(options: DashboardOptions): Promise<void>;
+/**
+ * Generate dashboard HTML from state (no GitHub fetch).
+ * Call after executeDailyCheck() which saves fresh data to state.
+ * Returns the path to the generated dashboard HTML file.
+ */
+export declare function writeDashboardFromState(): string;
+export {};

package/dist/commands/dashboard.js

@@ -0,0 +1,134 @@
+/**
+ * Dashboard command — thin orchestrator.
+ * Coordinates data fetching, template generation, and file output.
+ * v2: Fetches fresh data from GitHub if token available, otherwise uses cached lastDigest.
+ */
+import * as fs from 'fs';
+import { execFile } from 'child_process';
+import { getStateManager, getDashboardPath, getGitHubToken } from '../core/index.js';
+import { outputJson } from '../formatters/json.js';
+import { fetchDashboardData, computePRsByRepo, computeTopRepos, getMonthlyData } from './dashboard-data.js';
+import { buildDashboardStats, generateDashboardHtml } from './dashboard-templates.js';
+export async function runDashboard(options) {
+    const stateManager = getStateManager();
+    const token = options.offline ? null : getGitHubToken();
+    let digest;
+    let commentedIssues = [];
+    // In offline mode, skip all GitHub API calls
+    if (options.offline) {
+        const state = stateManager.getState();
+        digest = state.lastDigest;
+        if (!digest) {
+            if (options.json) {
+                outputJson({ error: 'No cached data found. Run without --offline first.', offline: true });
+            }
+            else {
+                console.error('No cached data found. Run without --offline first.');
+            }
+            return;
+        }
+        const lastUpdated = digest.generatedAt || state.lastDigestAt || state.lastRunAt;
+        console.error(`Offline mode: using cached data from ${lastUpdated}`);
+    }
+    else if (token) {
+        console.error('Fetching fresh data from GitHub...');
+        try {
+            const result = await fetchDashboardData(token);
+            digest = result.digest;
+            commentedIssues = result.commentedIssues;
+        }
+        catch (error) {
+            console.error('Failed to fetch fresh data:', error instanceof Error ? error.message : error);
+            console.error('Falling back to cached data (issue conversations unavailable)...');
+            digest = stateManager.getState().lastDigest;
+        }
+    }
+    else {
+        // No token and not offline — fall back to cached digest
+        digest = stateManager.getState().lastDigest;
+    }
+    // Check if we have a digest to display
+    if (!digest) {
+        if (options.json) {
+            outputJson({ error: 'No data available. Run daily check first with GITHUB_TOKEN.' });
+        }
+        else {
+            console.error('No dashboard data available. Run the daily check first:');
+            console.error('  GITHUB_TOKEN=$(gh auth token) npm start -- daily');
+        }
+        return;
+    }
+    const state = stateManager.getState();
+    // Gather data for charts from digest
+    const prsByRepo = computePRsByRepo(digest, state);
+    const topRepos = computeTopRepos(prsByRepo);
+    const { monthlyMerged, monthlyClosed, monthlyOpened } = getMonthlyData(state);
+    const stats = buildDashboardStats(digest, state);
+    if (options.json) {
+        const issueResponses = commentedIssues.filter((i) => i.status === 'new_response');
+        const jsonData = {
+            stats,
+            prsByRepo,
+            topRepos: topRepos.map(([repo, data]) => ({ repo, ...data })),
+            monthlyMerged,
+            activePRs: digest.openPRs || [],
+            commentedIssues,
+            issueResponses,
+        };
+        if (options.offline) {
+            jsonData.offline = true;
+            jsonData.lastUpdated = digest.generatedAt || state.lastDigestAt || state.lastRunAt;
+        }
+        outputJson(jsonData);
+        return;
+    }
+    const issueResponses = commentedIssues.filter((i) => i.status === 'new_response');
+    const html = generateDashboardHtml(stats, monthlyMerged, monthlyClosed, monthlyOpened, digest, state, issueResponses);
+    // Write to file in ~/.oss-autopilot/
+    const dashboardPath = getDashboardPath();
+    fs.writeFileSync(dashboardPath, html, { mode: 0o644 });
+    fs.chmodSync(dashboardPath, 0o644);
+    if (options.offline) {
+        const lastUpdated = digest.generatedAt || state.lastDigestAt || state.lastRunAt;
+        console.log(`\n📊 Dashboard generated (offline, cached data from ${lastUpdated}): ${dashboardPath}`);
+    }
+    else {
+        console.log(`\n📊 Dashboard generated: ${dashboardPath}`);
+    }
+    if (options.open) {
+        // Use platform-specific open command - path is hardcoded, not user input
+        const isWindows = process.platform === 'win32';
+        const openCmd = process.platform === 'darwin' ? 'open' : isWindows ? 'cmd' : 'xdg-open';
+        const args = isWindows ? ['/c', 'start', '', dashboardPath] : [dashboardPath];
+        console.log(`Dashboard: ${dashboardPath}`);
+        execFile(openCmd, args, (error) => {
+            if (error) {
+                console.error('Failed to open browser:', error.message);
+                console.error(`Open manually: ${dashboardPath}`);
+            }
+        });
+    }
+    else {
+        console.log('Run with --open to open in browser');
+    }
+}
+/**
+ * Generate dashboard HTML from state (no GitHub fetch).
+ * Call after executeDailyCheck() which saves fresh data to state.
+ * Returns the path to the generated dashboard HTML file.
+ */
+export function writeDashboardFromState() {
+    const stateManager = getStateManager();
+    const state = stateManager.getState();
+    const digest = state.lastDigest;
+    if (!digest) {
+        throw new Error('No digest data available. Run daily check first.');
+    }
+    const { monthlyMerged, monthlyClosed, monthlyOpened } = getMonthlyData(state);
+    const stats = buildDashboardStats(digest, state);
+    const html = generateDashboardHtml(stats, monthlyMerged, monthlyClosed, monthlyOpened, digest, state);
+    const dashboardPath = getDashboardPath();
+    fs.writeFileSync(dashboardPath, html, { mode: 0o644 });
+    fs.chmodSync(dashboardPath, 0o644);
+    return dashboardPath;
+}

package/dist/commands/dismiss.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Dismiss/Undismiss commands
+ * Manages dismissing issue reply notifications without posting a comment.
+ * Dismissed issues resurface automatically when new responses arrive after the dismiss timestamp.
+ */
+import { ISSUE_URL_PATTERN } from './validation.js';
+interface DismissCommandOptions {
+    issueUrl: string;
+    json?: boolean;
+}
+export { ISSUE_URL_PATTERN };
+export declare function runDismiss(options: DismissCommandOptions): Promise<void>;
+export declare function runUndismiss(options: DismissCommandOptions): Promise<void>;

package/dist/commands/dismiss.js

@@ -0,0 +1,49 @@
+/**
+ * Dismiss/Undismiss commands
+ * Manages dismissing issue reply notifications without posting a comment.
+ * Dismissed issues resurface automatically when new responses arrive after the dismiss timestamp.
+ */
+import { getStateManager } from '../core/index.js';
+import { outputJson } from '../formatters/json.js';
+import { ISSUE_URL_PATTERN, validateGitHubUrl, validateUrl } from './validation.js';
+// Re-export for backward compatibility with tests
+export { ISSUE_URL_PATTERN };
+export async function runDismiss(options) {
+    validateUrl(options.issueUrl);
+    validateGitHubUrl(options.issueUrl, ISSUE_URL_PATTERN, 'issue', options.json);
+    const stateManager = getStateManager();
+    const added = stateManager.dismissIssue(options.issueUrl, new Date().toISOString());
+    if (added) {
+        stateManager.save();
+    }
+    if (options.json) {
+        outputJson({ dismissed: added, url: options.issueUrl });
+    }
+    else if (added) {
+        console.log(`Dismissed: ${options.issueUrl}`);
+        console.log('Issue reply notifications are now muted.');
+        console.log('New responses after this point will resurface automatically.');
+    }
+    else {
+        console.log('Issue is already dismissed.');
+    }
+}
+export async function runUndismiss(options) {
+    validateUrl(options.issueUrl);
+    validateGitHubUrl(options.issueUrl, ISSUE_URL_PATTERN, 'issue', options.json);
+    const stateManager = getStateManager();
+    const removed = stateManager.undismissIssue(options.issueUrl);
+    if (removed) {
+        stateManager.save();
+    }
+    if (options.json) {
+        outputJson({ undismissed: removed, url: options.issueUrl });
+    }
+    else if (removed) {
+        console.log(`Undismissed: ${options.issueUrl}`);
+        console.log('Issue reply notifications are active again.');
+    }
+    else {
+        console.log('Issue was not dismissed.');
+    }
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Init command
+ * Initialize with GitHub username. In v2, PRs are fetched fresh on each daily run.
+ */
+interface InitOptions {
+    username: string;
+    json?: boolean;
+}
+export declare function runInit(options: InitOptions): Promise<void>;
+export {};

package/dist/commands/init.js

@@ -0,0 +1,27 @@
+/**
+ * Init command
+ * Initialize with GitHub username. In v2, PRs are fetched fresh on each daily run.
+ */
+import { getStateManager } from '../core/index.js';
+import { outputJson } from '../formatters/json.js';
+import { validateGitHubUsername } from './validation.js';
+export async function runInit(options) {
+    validateGitHubUsername(options.username);
+    const stateManager = getStateManager();
+    if (!options.json) {
+        console.log(`\n🚀 Initializing for @${options.username}...\n`);
+    }
+    // Set username in config
+    stateManager.updateConfig({ githubUsername: options.username });
+    stateManager.save();
+    if (options.json) {
+        outputJson({
+            username: options.username,
+            message: 'Username saved. Run `daily` to fetch your open PRs from GitHub.',
+        });
+    }
+    else {
+        console.log(`Username set to @${options.username}.`);
+        console.log('Run `oss-autopilot daily` to fetch your open PRs from GitHub.');
+    }
+}

package/dist/commands/local-repos.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Local repos command (#84)
+ * Scans configurable directories for local git clones and caches results
+ */
+import { type LocalRepoInfo } from '../formatters/json.js';
+interface LocalReposOptions {
+    scan?: boolean;
+    paths?: string[];
+    json?: boolean;
+}
+/** Scan directories for git repos, returning a map of owner/repo → local path */
+export declare function scanForRepos(scanPaths: string[]): Record<string, LocalRepoInfo>;
+export declare function runLocalRepos(options: LocalReposOptions): Promise<void>;
+export {};

package/dist/commands/local-repos.js

@@ -0,0 +1,155 @@
+/**
+ * Local repos command (#84)
+ * Scans configurable directories for local git clones and caches results
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { execFileSync } from 'child_process';
+import { getStateManager, debug } from '../core/index.js';
+import { outputJson } from '../formatters/json.js';
+/** Default directories to scan for local clones */
+const DEFAULT_SCAN_PATHS = [
+    path.join(os.homedir(), 'Documents', 'oss'),
+    path.join(os.homedir(), 'dev'),
+    path.join(os.homedir(), 'projects'),
+    path.join(os.homedir(), 'src'),
+    path.join(os.homedir(), 'code'),
+    path.join(os.homedir(), 'repos'),
+];
+/** Extract the GitHub "owner/repo" remote from a git directory */
+function getGitHubRemote(repoPath) {
+    try {
+        const remoteUrl = execFileSync('git', ['-C', repoPath, 'remote', 'get-url', 'origin'], {
+            encoding: 'utf-8',
+            timeout: 5000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        // Match HTTPS: https://github.com/owner/repo.git or https://github.com/owner/repo
+        const httpsMatch = remoteUrl.match(/github\.com\/([^/]+\/[^/]+?)(?:\.git)?$/);
+        if (httpsMatch)
+            return httpsMatch[1];
+        // Match SSH: git@github.com:owner/repo.git
+        const sshMatch = remoteUrl.match(/github\.com[:/]([^/]+\/[^/]+?)(?:\.git)?$/);
+        if (sshMatch)
+            return sshMatch[1];
+        return null;
+    }
+    catch (err) {
+        // git remote get-url failed (no remote, not a git repo, or timeout) — skip this repo
+        debug('local-repos', `Failed to get GitHub remote for ${repoPath}`, err);
+        return null;
+    }
+}
+/** Get the current branch of a git repo */
+function getCurrentBranch(repoPath) {
+    try {
+        return (execFileSync('git', ['-C', repoPath, 'branch', '--show-current'], {
+            encoding: 'utf-8',
+            timeout: 5000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim() || null);
+    }
+    catch (err) {
+        // git branch --show-current failed — repo may be in detached HEAD state or inaccessible
+        debug('local-repos', `Failed to get current branch for ${repoPath}`, err);
+        return null;
+    }
+}
+/** Scan directories for git repos, returning a map of owner/repo → local path */
+export function scanForRepos(scanPaths) {
+    const repos = {};
+    for (const scanPath of scanPaths) {
+        if (!fs.existsSync(scanPath))
+            continue;
+        // Find git repos up to 3 levels deep
+        let gitDirs;
+        try {
+            const output = execFileSync('find', [scanPath, '-maxdepth', '4', '-name', '.git', '-type', 'd'], {
+                encoding: 'utf-8',
+                timeout: 30000,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            }).trim();
+            gitDirs = output ? output.split('\n').filter(Boolean) : [];
+        }
+        catch (err) {
+            // find command failed for this scan path (permission denied, path gone, etc.) — skip it
+            debug('local-repos', `find failed for scan path ${scanPath}`, err);
+            continue;
+        }
+        for (const gitDir of gitDirs) {
+            const repoPath = path.dirname(gitDir);
+            const remote = getGitHubRemote(repoPath);
+            if (!remote)
+                continue;
+            const currentBranch = getCurrentBranch(repoPath);
+            repos[remote] = {
+                path: repoPath,
+                exists: true,
+                currentBranch,
+            };
+        }
+    }
+    return repos;
+}
+export async function runLocalRepos(options) {
+    const stateManager = getStateManager();
+    const state = stateManager.getState();
+    const scanPaths = options.paths?.map((p) => path.resolve(p)) ??
+        state.config.localRepoScanPaths ??
+        DEFAULT_SCAN_PATHS.filter((p) => fs.existsSync(p));
+    // Use cached data unless --scan is specified
+    if (!options.scan && state.localRepoCache) {
+        const cache = state.localRepoCache;
+        const result = {
+            repos: cache.repos,
+            scanPaths: cache.scanPaths,
+            cachedAt: cache.cachedAt,
+            fromCache: true,
+        };
+        if (options.json) {
+            outputJson(result);
+        }
+        else {
+            console.log(`\n📁 Local Repos (cached ${cache.cachedAt})\n`);
+            printRepos(cache.repos);
+        }
+        return;
+    }
+    if (!options.json) {
+        console.log(`\n🔍 Scanning for local repos in ${scanPaths.length} directories...\n`);
+    }
+    const repos = scanForRepos(scanPaths);
+    const repoCount = Object.keys(repos).length;
+    // Cache the results in state
+    const cachedAt = new Date().toISOString();
+    try {
+        stateManager.setLocalRepoCache({ repos, scanPaths, cachedAt });
+        stateManager.save();
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(`Warning: Failed to cache scan results: ${msg}`);
+    }
+    const result = {
+        repos,
+        scanPaths,
+        cachedAt,
+        fromCache: false,
+    };
+    if (options.json) {
+        outputJson(result);
+    }
+    else {
+        console.log(`Found ${repoCount} repos:\n`);
+        printRepos(repos);
+    }
+}
+function printRepos(repos) {
+    const entries = Object.entries(repos).sort(([a], [b]) => a.localeCompare(b));
+    for (const [remote, info] of entries) {
+        const branch = info.currentBranch ? ` (${info.currentBranch})` : '';
+        console.log(`  ${remote}${branch}`);
+        console.log(`    ${info.path}`);
+    }
+}

package/dist/commands/parse-list.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Parse issue list command (#82)
+ * Parses markdown issue lists into structured JSON with tier classification
+ */
+import { type ParseIssueListOutput } from '../formatters/json.js';
+interface ParseListOptions {
+    filePath: string;
+    json?: boolean;
+}
+/** Parse a markdown string into structured issue items */
+export declare function parseIssueList(content: string): ParseIssueListOutput;
+export declare function runParseList(options: ParseListOptions): Promise<void>;
+export {};

package/dist/commands/parse-list.js

@@ -0,0 +1,139 @@
+/**
+ * Parse issue list command (#82)
+ * Parses markdown issue lists into structured JSON with tier classification
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { outputJson, outputJsonError } from '../formatters/json.js';
+/** Extract GitHub issue/PR URLs from a markdown line */
+function extractGitHubUrl(line) {
+    const match = line.match(/https:\/\/github\.com\/([^/]+\/[^/]+)\/issues\/(\d+)/);
+    if (match) {
+        return { repo: match[1], number: parseInt(match[2], 10), url: match[0] };
+    }
+    const prMatch = line.match(/https:\/\/github\.com\/([^/]+\/[^/]+)\/pull\/(\d+)/);
+    if (prMatch) {
+        return { repo: prMatch[1], number: parseInt(prMatch[2], 10), url: prMatch[0] };
+    }
+    return null;
+}
+/** Extract issue title from a markdown line (text after URL or checkbox) */
+function extractTitle(line) {
+    // Remove markdown link syntax: [title](url) → title
+    let cleaned = line.replace(/\[([^\]]+)\]\([^)]+\)/g, '$1');
+    // Remove bare URLs
+    cleaned = cleaned.replace(/https?:\/\/\S+/g, '');
+    // Remove list markers (-, *, +, numbered)
+    cleaned = cleaned.replace(/^\s*[-*+]\s*/, '').replace(/^\s*\d+\.\s*/, '');
+    // Remove checkboxes
+    cleaned = cleaned.replace(/\[[ xX]\]\s*/, '');
+    // Remove strikethrough markers
+    cleaned = cleaned.replace(/~~/g, '');
+    // Remove "Done" markers
+    cleaned = cleaned.replace(/\b(Done|DONE|done)\b/g, '');
+    // Remove leading/trailing punctuation and whitespace
+    cleaned = cleaned.replace(/^[\s\-–—:]+/, '').replace(/[\s\-–—:]+$/, '');
+    return cleaned.trim();
+}
+/** Determine if a line represents a completed item */
+function isCompleted(line) {
+    // Strikethrough: ~~text~~
+    if (/~~.+~~/.test(line))
+        return true;
+    // Checked checkbox: [x] or [X]
+    if (/\[[xX]\]/.test(line))
+        return true;
+    // "Done" marker (standalone word, case insensitive)
+    if (/\bdone\b/i.test(line))
+        return true;
+    return false;
+}
+/** Parse a markdown string into structured issue items */
+export function parseIssueList(content) {
+    const lines = content.split('\n');
+    const available = [];
+    const completed = [];
+    let currentTier = 'Uncategorized';
+    for (const line of lines) {
+        // Check for section headings (# or ##)
+        const headingMatch = line.match(/^#{1,3}\s+(.+)/);
+        if (headingMatch) {
+            currentTier = headingMatch[1].trim();
+            continue;
+        }
+        // Skip empty lines and non-list items
+        if (!line.trim() || !/^\s*[-*+]|\s*\d+\.|\s*\[[ xX]\]/.test(line)) {
+            continue;
+        }
+        // Extract GitHub URL — skip lines without one
+        const ghUrl = extractGitHubUrl(line);
+        if (!ghUrl)
+            continue;
+        const title = extractTitle(line);
+        const item = {
+            repo: ghUrl.repo,
+            number: ghUrl.number,
+            title: title || `#${ghUrl.number}`,
+            tier: currentTier,
+            url: ghUrl.url,
+        };
+        if (isCompleted(line)) {
+            completed.push(item);
+        }
+        else {
+            available.push(item);
+        }
+    }
+    return {
+        available,
+        completed,
+        availableCount: available.length,
+        completedCount: completed.length,
+    };
+}
+export async function runParseList(options) {
+    const filePath = path.resolve(options.filePath);
+    if (!fs.existsSync(filePath)) {
+        if (options.json) {
+            outputJsonError(`File not found: ${filePath}`);
+        }
+        else {
+            console.error(`Error: File not found: ${filePath}`);
+        }
+        process.exit(1);
+    }
+    let content;
+    try {
+        content = fs.readFileSync(filePath, 'utf-8');
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (options.json) {
+            outputJsonError(`Failed to read file: ${msg}`);
+        }
+        else {
+            console.error(`Error: Failed to read file: ${msg}`);
+        }
+        process.exit(1);
+    }
+    const result = parseIssueList(content);
+    if (options.json) {
+        outputJson(result);
+    }
+    else {
+        console.log(`\n📋 Issue List: ${filePath}\n`);
+        console.log(`Available: ${result.availableCount} | Completed: ${result.completedCount}\n`);
+        if (result.available.length > 0) {
+            console.log('--- Available ---');
+            for (const item of result.available) {
+                console.log(`  [${item.tier}] ${item.repo}#${item.number}: ${item.title}`);
+            }
+        }
+        if (result.completed.length > 0) {
+            console.log('\n--- Completed ---');
+            for (const item of result.completed) {
+                console.log(`  [${item.tier}] ${item.repo}#${item.number}: ${item.title}`);
+            }
+        }
+    }
+}

package/dist/commands/read.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Read command
+ * In v2, PR read/unread state is not tracked locally.
+ * This command is a no-op preserved for backward compatibility.
+ */
+interface ReadOptions {
+    prUrl?: string;
+    all?: boolean;
+    json?: boolean;
+}
+export declare function runRead(options: ReadOptions): Promise<void>;
+export {};

package/dist/commands/read.js

@@ -0,0 +1,33 @@
+/**
+ * Read command
+ * In v2, PR read/unread state is not tracked locally.
+ * This command is a no-op preserved for backward compatibility.
+ */
+import { outputJson, outputJsonError } from '../formatters/json.js';
+import { validateUrl } from './validation.js';
+export async function runRead(options) {
+    if (!options.all && !options.prUrl) {
+        if (options.json) {
+            outputJsonError('PR URL or --all flag required');
+        }
+        else {
+            console.error('Usage: oss-autopilot read <pr-url> or oss-autopilot read --all');
+        }
+        process.exit(1);
+    }
+    if (options.prUrl) {
+        validateUrl(options.prUrl);
+    }
+    // In v2, unread state is not tracked locally — PRs are fetched fresh each run.
+    if (options.json) {
+        if (options.all) {
+            outputJson({ markedAsRead: 0, all: true, message: 'In v2, PR read state is not tracked locally.' });
+        }
+        else {
+            outputJson({ marked: false, url: options.prUrl, message: 'In v2, PR read state is not tracked locally.' });
+        }
+    }
+    else {
+        console.log('Note: In v2, PR read state is not tracked locally. PRs are fetched fresh on each daily run.');
+    }
+}

package/dist/commands/search.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Search command
+ * Searches for new issues to work on
+ */
+interface SearchOptions {
+    maxResults: number;
+    json?: boolean;
+}
+export declare function runSearch(options: SearchOptions): Promise<void>;
+export {};