@oss-autopilot/core 0.49.0 → 0.50.0

package/dist/commands/dashboard-server.js

@@ -11,7 +11,7 @@ import * as path from 'path';
 import { getStateManager, getGitHubToken, getCLIVersion, applyStatusOverrides } from '../core/index.js';
 import { errorMessage, ValidationError } from '../core/errors.js';
 import { warn } from '../core/logger.js';
-import { validateUrl, validateGitHubUrl, PR_URL_PATTERN } from './validation.js';
+import { validateUrl, validateGitHubUrl, PR_URL_PATTERN, ISSUE_OR_PR_URL_PATTERN } from './validation.js';
 import { fetchDashboardData, computePRsByRepo, computeTopRepos, getMonthlyData, buildDashboardStats, storedToMergedPRs, storedToClosedPRs, } from './dashboard-data.js';
 import { openInBrowser } from './startup.js';
 import { writeDashboardServerInfo, removeDashboardServerInfo } from './dashboard-process.js';
@@ -20,7 +20,12 @@ import { isBelowMinStars, } from '../core/types.js';
 // Re-export process management functions for backward compatibility
 export { getDashboardPidPath, writeDashboardServerInfo, readDashboardServerInfo, removeDashboardServerInfo, isDashboardServerRunning, findRunningDashboardServer, } from './dashboard-process.js';
 // ── Constants ────────────────────────────────────────────────────────────────
-const VALID_ACTIONS = new Set(['shelve', 'unshelve', 'override_status']);
+const VALID_ACTIONS = new Set([
+    'shelve',
+    'unshelve',
+    'override_status',
+    'dismiss_issue_response',
+]);
 const MODULE = 'dashboard-server';
 const MAX_BODY_BYTES = 10_240;
 const REQUEST_TIMEOUT_MS = 30_000;
@@ -51,7 +56,8 @@ function buildDashboardJson(digest, state, commentedIssues, allMergedPRs, allClo
     const filteredMergedPRs = mergedPRs.filter(isAboveMinStars);
     const filteredClosedPRs = closedPRs.filter(isAboveMinStars);
     const stats = buildDashboardStats(digest, state, filteredMergedPRs.length, filteredClosedPRs.length);
-    const issueResponses = commentedIssues.filter((i) => i.status === 'new_response');
+    const dismissedIssues = state.config.dismissedIssues || {};
+    const issueResponses = commentedIssues.filter((i) => i.status === 'new_response' && !(i.url in dismissedIssues));
     return {
         stats,
         prsByRepo,
@@ -244,10 +250,11 @@ export async function startDashboardServer(options) {
             sendError(res, 400, 'Missing or invalid "url" field');
             return;
         }
-        // Validate URL format — all actions are PR-only now.
+        // Validate URL format — dismiss_issue_response accepts issue or PR URLs, others are PR-only.
+        const isDismiss = body.action === 'dismiss_issue_response';
         try {
             validateUrl(body.url);
-            validateGitHubUrl(body.url, PR_URL_PATTERN, 'PR');
+            validateGitHubUrl(body.url, isDismiss ? ISSUE_OR_PR_URL_PATTERN : PR_URL_PATTERN, isDismiss ? 'issue or PR' : 'PR');
         }
         catch (err) {
             if (err instanceof ValidationError) {
@@ -283,6 +290,9 @@ export async function startDashboardServer(options) {
                     stateManager.setStatusOverride(body.url, overrideStatus, lastActivityAt);
                     break;
                 }
+                case 'dismiss_issue_response':
+                    stateManager.dismissIssue(body.url, new Date().toISOString());
+                    break;
             }
             stateManager.save();
         }

package/dist/commands/setup.d.ts

@@ -2,6 +2,7 @@
  * Setup command
  * Interactive setup / configuration
  */
+import { type ProjectCategory } from '../core/types.js';
 interface SetupOptions {
     reset?: boolean;
     set?: string[];
@@ -20,6 +21,8 @@ export interface SetupCompleteOutput {
         approachingDormantDays: number;
         languages: string[];
         labels: string[];
+        projectCategories: ProjectCategory[];
+        preferredOrgs: string[];
     };
 }
 export interface SetupPrompt {

package/dist/commands/setup.js

@@ -5,6 +5,7 @@
 import { getStateManager, DEFAULT_CONFIG } from '../core/index.js';
 import { ValidationError } from '../core/errors.js';
 import { validateGitHubUsername } from './validation.js';
+import { PROJECT_CATEGORIES } from '../core/types.js';
 /** Parse and validate a positive integer setting value. */
 function parsePositiveInt(value, settingName) {
     const parsed = Number(value);
@@ -111,6 +112,51 @@ export async function runSetup(options) {
                     results[key] = valid.length > 0 ? valid.join(', ') : '(empty)';
                     break;
                 }
+                case 'projectCategories': {
+                    const categories = value
+                        .split(',')
+                        .map((c) => c.trim())
+                        .filter(Boolean);
+                    const validCategories = [];
+                    const invalidCategories = [];
+                    for (const cat of categories) {
+                        if (PROJECT_CATEGORIES.includes(cat)) {
+                            validCategories.push(cat);
+                        }
+                        else {
+                            invalidCategories.push(cat);
+                        }
+                    }
+                    if (invalidCategories.length > 0) {
+                        warnings.push(`Unknown project categories: ${invalidCategories.join(', ')}. Valid: ${PROJECT_CATEGORIES.join(', ')}`);
+                    }
+                    const dedupedCategories = [...new Set(validCategories)];
+                    stateManager.updateConfig({ projectCategories: dedupedCategories });
+                    results[key] = dedupedCategories.length > 0 ? dedupedCategories.join(', ') : '(empty)';
+                    break;
+                }
+                case 'preferredOrgs': {
+                    const orgs = value
+                        .split(',')
+                        .map((o) => o.trim())
+                        .filter(Boolean);
+                    const validOrgs = [];
+                    for (const org of orgs) {
+                        if (org.includes('/')) {
+                            warnings.push(`"${org}" looks like a repo path. Use org name only (e.g., "vercel" not "vercel/next.js").`);
+                        }
+                        else if (!/^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?$/.test(org)) {
+                            warnings.push(`"${org}" is not a valid GitHub organization name. Skipping.`);
+                        }
+                        else {
+                            validOrgs.push(org.toLowerCase());
+                        }
+                    }
+                    const dedupedOrgs = [...new Set(validOrgs)];
+                    stateManager.updateConfig({ preferredOrgs: dedupedOrgs });
+                    results[key] = dedupedOrgs.length > 0 ? dedupedOrgs.join(', ') : '(empty)';
+                    break;
+                }
                 case 'complete':
                     if (value === 'true') {
                         stateManager.markSetupComplete();
@@ -135,6 +181,8 @@ export async function runSetup(options) {
                 approachingDormantDays: config.approachingDormantDays,
                 languages: config.languages,
                 labels: config.labels,
+                projectCategories: config.projectCategories ?? [],
+                preferredOrgs: config.preferredOrgs ?? [],
             },
         };
     }
@@ -191,6 +239,20 @@ export async function runSetup(options) {
                 default: ['matplotlib/matplotlib'],
                 type: 'list',
             },
+            {
+                setting: 'projectCategories',
+                prompt: 'What types of projects interest you? (nonprofit, devtools, infrastructure, web-frameworks, data-ml, education)',
+                current: config.projectCategories ?? [],
+                default: [],
+                type: 'list',
+            },
+            {
+                setting: 'preferredOrgs',
+                prompt: 'Any GitHub organizations to prioritize? (org names, comma-separated)',
+                current: config.preferredOrgs ?? [],
+                default: [],
+                type: 'list',
+            },
         ],
     };
 }

package/dist/core/category-mapping.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Category Mapping — static mappings from project categories to GitHub topics and organizations.
+ *
+ * Used by issue discovery to prioritize repos matching user's category preferences.
+ */
+import type { ProjectCategory } from './types.js';
+/** GitHub topics associated with each project category, used for `topic:` search queries. */
+export declare const CATEGORY_TOPICS: Record<ProjectCategory, string[]>;
+/** Well-known GitHub organizations associated with each project category. */
+export declare const CATEGORY_ORGS: Record<ProjectCategory, string[]>;
+/**
+ * Check if a repo belongs to any of the given categories based on its owner matching a category org.
+ * Comparison is case-insensitive.
+ */
+export declare function repoBelongsToCategory(repoFullName: string, categories: ProjectCategory[]): boolean;
+/**
+ * Get deduplicated GitHub topics for the given categories, for use in `topic:` search queries.
+ */
+export declare function getTopicsForCategories(categories: ProjectCategory[]): string[];

package/dist/core/category-mapping.js

@@ -0,0 +1,58 @@
+/**
+ * Category Mapping — static mappings from project categories to GitHub topics and organizations.
+ *
+ * Used by issue discovery to prioritize repos matching user's category preferences.
+ */
+/** GitHub topics associated with each project category, used for `topic:` search queries. */
+export const CATEGORY_TOPICS = {
+    nonprofit: ['nonprofit', 'social-good', 'humanitarian', 'charity', 'social-impact', 'civic-tech'],
+    devtools: ['developer-tools', 'devtools', 'cli', 'sdk', 'linter', 'formatter', 'build-tool'],
+    infrastructure: ['infrastructure', 'cloud', 'kubernetes', 'docker', 'devops', 'monitoring', 'observability'],
+    'web-frameworks': ['web-framework', 'frontend', 'backend', 'fullstack', 'nextjs', 'react', 'vue'],
+    'data-ml': ['machine-learning', 'data-science', 'deep-learning', 'nlp', 'data-pipeline', 'analytics'],
+    education: ['education', 'learning', 'tutorial', 'courseware', 'edtech', 'teaching'],
+};
+/** Well-known GitHub organizations associated with each project category. */
+export const CATEGORY_ORGS = {
+    nonprofit: ['code-for-america', 'opengovfoundation', 'ushahidi', 'hotosm', 'openfn', 'democracyearth'],
+    devtools: ['eslint', 'prettier', 'vitejs', 'biomejs', 'oxc-project', 'ast-grep', 'turbot'],
+    infrastructure: ['kubernetes', 'hashicorp', 'grafana', 'prometheus', 'open-telemetry', 'envoyproxy', 'cncf'],
+    'web-frameworks': ['vercel', 'remix-run', 'sveltejs', 'nuxt', 'astro', 'redwoodjs', 'blitz-js'],
+    'data-ml': ['huggingface', 'mlflow', 'apache', 'dbt-labs', 'dagster-io', 'prefecthq', 'langchain-ai'],
+    education: ['freeCodeCamp', 'TheOdinProject', 'exercism', 'codecademy', 'oppia', 'Khan'],
+};
+/**
+ * Check if a repo belongs to any of the given categories based on its owner matching a category org.
+ * Comparison is case-insensitive.
+ */
+export function repoBelongsToCategory(repoFullName, categories) {
+    if (categories.length === 0)
+        return false;
+    const owner = repoFullName.split('/')[0]?.toLowerCase();
+    if (!owner)
+        return false;
+    for (const category of categories) {
+        const orgs = CATEGORY_ORGS[category];
+        if (!orgs)
+            continue; // Guard against invalid categories from hand-edited state.json
+        if (orgs.some((org) => org.toLowerCase() === owner)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Get deduplicated GitHub topics for the given categories, for use in `topic:` search queries.
+ */
+export function getTopicsForCategories(categories) {
+    const topics = new Set();
+    for (const category of categories) {
+        const categoryTopics = CATEGORY_TOPICS[category];
+        if (!categoryTopics)
+            continue; // Guard against invalid categories from hand-edited state.json
+        for (const topic of categoryTopics) {
+            topics.add(topic);
+        }
+    }
+    return [...topics];
+}

package/dist/core/daily-logic.js

@@ -294,10 +294,15 @@ export function computeActionMenu(actionableIssues, capacity, commentedIssues =
     const hasActionableIssues = actionableIssues.length > 0;
     const hasIssueResponses = issueResponses.length > 0;
     if (hasActionableIssues) {
+        const isSingle = actionableIssues.length === 1;
         items.push({
             key: 'address_all',
-            label: `Work through all ${actionableIssues.length} issue${actionableIssues.length === 1 ? '' : 's'} (Recommended)`,
-            description: 'Run maintenance in parallel, then address code changes one at a time',
+            label: isSingle
+                ? 'Address this issue (Recommended)'
+                : `Work through all ${actionableIssues.length} issues (Recommended)`,
+            description: isSingle
+                ? 'Fix the issue blocking your PR'
+                : 'Run maintenance in parallel, then address code changes one at a time',
         });
     }
     // Issue replies — positioned after address_all but before search

package/dist/core/issue-discovery.js

@@ -18,6 +18,7 @@ import { getHttpCache, cachedTimeBased } from './http-cache.js';
 import { isDocOnlyIssue, detectLabelFarmingRepos, applyPerRepoCap } from './issue-filtering.js';
 import { IssueVetter } from './issue-vetting.js';
 import { calculateViabilityScore as calcViabilityScore } from './issue-scoring.js';
+import { getTopicsForCategories } from './category-mapping.js';
 // Re-export everything from sub-modules for backward compatibility.
 // Existing consumers (tests, CLI commands) import from './issue-discovery.js'.
 export { isDocOnlyIssue, applyPerRepoCap, isLabelFarming, hasTemplatedTitle, detectLabelFarmingRepos, DOC_ONLY_LABELS, BEGINNER_LABELS, } from './issue-filtering.js';
@@ -282,6 +283,51 @@ export class IssueDiscovery {
                 }
             }
         }
+        // Phase 0.5: Search preferred organizations (explicit user preference)
+        let phase0_5Error = null;
+        const preferredOrgs = config.preferredOrgs ?? [];
+        if (allCandidates.length < maxResults && preferredOrgs.length > 0) {
+            // Filter out orgs already covered by Phase 0 repos
+            const phase0Orgs = new Set(phase0Repos.map((r) => r.split('/')[0]?.toLowerCase()));
+            const orgsToSearch = preferredOrgs.filter((org) => !phase0Orgs.has(org.toLowerCase())).slice(0, 5);
+            if (orgsToSearch.length > 0) {
+                info(MODULE, `Phase 0.5: Searching issues in ${orgsToSearch.length} preferred org(s)...`);
+                const remainingNeeded = maxResults - allCandidates.length;
+                const orgRepoFilter = orgsToSearch.map((org) => `org:${org}`).join(' OR ');
+                const orgQuery = `${baseQuery} (${orgRepoFilter})`;
+                try {
+                    const data = await this.cachedSearch({
+                        q: orgQuery,
+                        sort: 'created',
+                        order: 'desc',
+                        per_page: remainingNeeded * 3,
+                    });
+                    if (data.items.length > 0) {
+                        const filtered = filterIssues(data.items).filter((item) => {
+                            const repoFullName = item.repository_url.split('/').slice(-2).join('/');
+                            return !phase0RepoSet.has(repoFullName);
+                        });
+                        const { candidates: orgCandidates, allFailed: allVetFailed, rateLimitHit, } = await this.vetter.vetIssuesParallel(filtered.slice(0, remainingNeeded * 2).map((i) => i.html_url), remainingNeeded, 'preferred_org');
+                        allCandidates.push(...orgCandidates);
+                        if (allVetFailed) {
+                            phase0_5Error = 'All preferred org issue vetting failed';
+                        }
+                        if (rateLimitHit) {
+                            rateLimitHitDuringSearch = true;
+                        }
+                        info(MODULE, `Found ${orgCandidates.length} candidates from preferred orgs`);
+                    }
+                }
+                catch (error) {
+                    const errMsg = errorMessage(error);
+                    phase0_5Error = errMsg;
+                    if (isRateLimitError(error)) {
+                        rateLimitHitDuringSearch = true;
+                    }
+                    warn(MODULE, `Error searching preferred orgs: ${errMsg}`);
+                }
+            }
+        }
         // Phase 1: Search starred repos (filter out already-searched Phase 0 repos)
         if (allCandidates.length < maxResults && starredRepos.length > 0) {
             const reposToSearch = starredRepos.filter((r) => !phase0RepoSet.has(r));
@@ -345,7 +391,12 @@ export class IssueDiscovery {
             const thirtyDaysAgo = new Date();
             thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
             const pushedSince = thirtyDaysAgo.toISOString().split('T')[0];
-            const phase3Query = `is:issue is:open no:assignee ${langQuery} stars:>=${minStars} pushed:>=${pushedSince} archived:false`
+            // When user has category preferences, add a single topic filter to focus on relevant repos.
+            // GitHub Search API AND-joins multiple topic: qualifiers, which is overly restrictive,
+            // so we pick just the first topic to nudge results without eliminating valid matches.
+            const categoryTopics = getTopicsForCategories(config.projectCategories ?? []);
+            const topicQuery = categoryTopics.length > 0 ? `topic:${categoryTopics[0]}` : '';
+            const phase3Query = `is:issue is:open no:assignee ${langQuery} ${topicQuery} stars:>=${minStars} pushed:>=${pushedSince} archived:false`
                 .replace(/  +/g, ' ')
                 .trim();
             try {
@@ -379,6 +430,7 @@ export class IssueDiscovery {
         if (allCandidates.length === 0) {
             const phaseErrors = [
                 phase0Error ? `Phase 0 (merged-PR repos): ${phase0Error}` : null,
+                phase0_5Error ? `Phase 0.5 (preferred orgs): ${phase0_5Error}` : null,
                 phase1Error ? `Phase 1 (starred repos): ${phase1Error}` : null,
                 phase2Error ? `Phase 2 (general): ${phase2Error}` : null,
                 phase3Error ? `Phase 3 (maintained repos): ${phase3Error}` : null,
@@ -406,8 +458,8 @@ export class IssueDiscovery {
         }
         // Sort by priority first, then by recommendation, then by viability score
         allCandidates.sort((a, b) => {
-            // Priority order: merged_pr > starred > normal
-            const priorityOrder = { merged_pr: 0, starred: 1, normal: 2 };
+            // Priority order: merged_pr > preferred_org > starred > normal
+            const priorityOrder = { merged_pr: 0, preferred_org: 1, starred: 2, normal: 3 };
             const priorityDiff = priorityOrder[a.searchPriority] - priorityOrder[b.searchPriority];
             if (priorityDiff !== 0)
                 return priorityDiff;

package/dist/core/issue-scoring.d.ts

@@ -21,6 +21,8 @@ export interface ViabilityScoreParams {
     mergedPRCount: number;
     orgHasMergedPRs: boolean;
     repoQualityBonus?: number;
+    /** True when the repo matches one of the user's preferred project categories. */
+    matchesPreferredCategory?: boolean;
 }
 /**
  * Calculate viability score for an issue (0-100 scale)
@@ -33,6 +35,7 @@ export interface ViabilityScoreParams {
  * - +15 for freshness (recently updated)
  * - +10 for contribution guidelines
  * - +5 for org affinity (merged PRs in same org)
+ * - +5 for category preference (matches user's project categories)
  * - -30 if existing PR
  * - -20 if claimed
  * - -15 if closed-without-merge history with no merges

package/dist/core/issue-scoring.js

@@ -37,6 +37,7 @@ export function calculateRepoQualityBonus(stargazersCount, forksCount) {
  * - +15 for freshness (recently updated)
  * - +10 for contribution guidelines
  * - +5 for org affinity (merged PRs in same org)
+ * - +5 for category preference (matches user's project categories)
  * - -30 if existing PR
  * - -20 if claimed
  * - -15 if closed-without-merge history with no merges
@@ -75,6 +76,10 @@ export function calculateViabilityScore(params) {
     if (params.orgHasMergedPRs) {
         score += 5;
     }
+    // Category preference bonus (+5) — repo matches user's preferred project categories
+    if (params.matchesPreferredCategory) {
+        score += 5;
+    }
     // Penalty for existing PR (-30)
     if (params.hasExistingPR) {
         score -= 30;

package/dist/core/issue-vetting.js

@@ -10,6 +10,7 @@ import { ValidationError, errorMessage, isRateLimitError } from './errors.js';
 import { warn } from './logger.js';
 import { getHttpCache, cachedRequest, cachedTimeBased } from './http-cache.js';
 import { calculateRepoQualityBonus, calculateViabilityScore } from './issue-scoring.js';
+import { repoBelongsToCategory } from './category-mapping.js';
 const MODULE = 'issue-vetting';
 const MAX_CONCURRENT_REQUESTS = DEFAULT_CONCURRENCY;
 // Cache for contribution guidelines (expires after 1 hour, max 100 entries)
@@ -173,6 +174,12 @@ export class IssueVetter {
         if (orgHasMergedPRs) {
             reasonsToApprove.push(`Org affinity (merged PRs in other ${orgName} repos)`);
         }
+        // Check for category preference match
+        const projectCategories = config.projectCategories ?? [];
+        const matchesCategory = repoBelongsToCategory(repoFullName, projectCategories);
+        if (matchesCategory) {
+            reasonsToApprove.push('Matches preferred project category');
+        }
         let recommendation;
         if (vettingResult.passedAllChecks) {
             recommendation = 'approve';
@@ -207,12 +214,17 @@ export class IssueVetter {
             mergedPRCount: effectiveMergedCount,
             orgHasMergedPRs,
             repoQualityBonus,
+            matchesPreferredCategory: matchesCategory,
         });
         const starredRepos = this.stateManager.getStarredRepos();
+        const preferredOrgs = config.preferredOrgs ?? [];
         let searchPriority = 'normal';
         if (effectiveMergedCount > 0) {
             searchPriority = 'merged_pr';
         }
+        else if (preferredOrgs.some((o) => o.toLowerCase() === orgName?.toLowerCase())) {
+            searchPriority = 'preferred_org';
+        }
         else if (starredRepos.includes(repoFullName)) {
             searchPriority = 'starred';
         }

package/dist/core/types.d.ts

@@ -485,6 +485,10 @@ export interface AgentConfig {
     snoozedPRs?: Record<string, SnoozeInfo>;
     /** Manual status overrides for PRs. Maps PR URL to override metadata. Auto-clears when the PR has new activity. */
     statusOverrides?: Record<string, StatusOverride>;
+    /** Project categories the user is interested in (e.g., devtools, nonprofit). Used to prioritize search results. */
+    projectCategories?: ProjectCategory[];
+    /** GitHub organizations the user wants to prioritize in issue search. Org names only (not owner/repo). */
+    preferredOrgs?: string[];
 }
 /** Status of a user's comment thread on a GitHub issue. */
 export type IssueConversationStatus = 'new_response' | 'waiting' | 'acknowledged';
@@ -523,7 +527,10 @@ export type CommentedIssue = CommentedIssueWithResponse | CommentedIssueWithoutR
 export declare const DEFAULT_CONFIG: AgentConfig;
 /** Initial state written to `~/.oss-autopilot/state.json` on first run. Uses v2 architecture. */
 export declare const INITIAL_STATE: AgentState;
-export type SearchPriority = 'merged_pr' | 'starred' | 'normal';
+export declare const PROJECT_CATEGORIES: readonly ["nonprofit", "devtools", "infrastructure", "web-frameworks", "data-ml", "education"];
+export type ProjectCategory = (typeof PROJECT_CATEGORIES)[number];
+/** Priority tier for issue search results. Ordered: merged_pr > preferred_org > starred > normal. */
+export type SearchPriority = 'merged_pr' | 'preferred_org' | 'starred' | 'normal';
 export interface IssueCandidate {
     issue: TrackedIssue;
     vettingResult: IssueVettingResult;

package/dist/core/types.js

@@ -29,6 +29,8 @@ export const DEFAULT_CONFIG = {
     shelvedPRUrls: [],
     dismissedIssues: {},
     snoozedPRs: {},
+    projectCategories: [],
+    preferredOrgs: [],
 };
 /** Initial state written to `~/.oss-autopilot/state.json` on first run. Uses v2 architecture. */
 export const INITIAL_STATE = {
@@ -39,3 +41,12 @@ export const INITIAL_STATE = {
     events: [],
     lastRunAt: new Date().toISOString(),
 };
+// -- Project category types --
+export const PROJECT_CATEGORIES = [
+    'nonprofit',
+    'devtools',
+    'infrastructure',
+    'web-frameworks',
+    'data-ml',
+    'education',
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oss-autopilot/core",
-  "version": "0.49.0",
+  "version": "0.50.0",
   "description": "CLI and core library for managing open source contributions",
   "type": "module",
   "bin": {