@oss-autopilot/core 1.1.0 → 1.3.0

package/dist/commands/config.js

@@ -3,6 +3,7 @@
  * Shows or updates configuration
  */
 import { getStateManager } from '../core/index.js';
+import { ValidationError } from '../core/errors.js';
 import { ISSUE_SCOPES } from '../core/types.js';
 import { validateGitHubUsername } from './validation.js';
 function validateScope(value) {
@@ -105,6 +106,14 @@ export async function runConfig(options) {
         case 'issueListPath':
             stateManager.updateConfig({ issueListPath: value || undefined });
             break;
+        case 'scoreThreshold': {
+            const threshold = Number(value);
+            if (!Number.isInteger(threshold) || threshold < 1 || threshold > 10) {
+                throw new ValidationError(`Invalid value for scoreThreshold: "${value}". Must be an integer between 1 and 10.`);
+            }
+            stateManager.updateConfig({ scoreThreshold: threshold });
+            break;
+        }
         default:
             throw new Error(`Unknown config key: ${options.key}`);
     }

package/dist/commands/setup.d.ts

@@ -24,6 +24,7 @@ export interface SetupCompleteOutput {
         projectCategories: ProjectCategory[];
         preferredOrgs: string[];
         scope: IssueScope[];
+        scoreThreshold: number;
     };
 }
 export interface SetupPrompt {

package/dist/commands/setup.js

@@ -9,11 +9,19 @@ import { PROJECT_CATEGORIES, ISSUE_SCOPES } from '../core/types.js';
 /** Parse and validate a positive integer setting value. */
 function parsePositiveInt(value, settingName) {
     const parsed = Number(value);
-    if (!Number.isFinite(parsed) || parsed < 1 || !Number.isInteger(parsed)) {
+    if (!Number.isInteger(parsed) || parsed < 1) {
         throw new ValidationError(`Invalid value for ${settingName}: "${value}". Must be a positive integer.`);
     }
     return parsed;
 }
+/** Parse and validate an integer within a specific range [min, max]. */
+function parseBoundedInt(value, settingName, min, max) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < min || parsed > max) {
+        throw new ValidationError(`Invalid value for ${settingName}: "${value}". Must be an integer between ${min} and ${max}.`);
+    }
+    return parsed;
+}
 /**
  * Interactive setup wizard or direct setting application.
  *
@@ -84,9 +92,15 @@ export async function runSetup(options) {
                             results[key] = value !== 'false' ? 'true' : 'false';
                         }
                         break;
+                    case 'scoreThreshold': {
+                        const threshold = parseBoundedInt(value, 'scoreThreshold', 1, 10);
+                        stateManager.updateConfig({ scoreThreshold: threshold });
+                        results[key] = String(threshold);
+                        break;
+                    }
                     case 'minStars': {
                         const stars = Number(value);
-                        if (!Number.isFinite(stars) || !Number.isInteger(stars) || stars < 0) {
+                        if (!Number.isInteger(stars) || stars < 0) {
                             throw new ValidationError(`Invalid value for minStars: "${value}". Must be a non-negative integer.`);
                         }
                         stateManager.updateConfig({ minStars: stars });
@@ -225,6 +239,7 @@ export async function runSetup(options) {
                 projectCategories: config.projectCategories ?? [],
                 preferredOrgs: config.preferredOrgs ?? [],
                 scope: config.scope ?? [],
+                scoreThreshold: config.scoreThreshold,
             },
         };
     }
@@ -281,6 +296,13 @@ export async function runSetup(options) {
                 default: [],
                 type: 'list',
             },
+            {
+                setting: 'scoreThreshold',
+                prompt: 'Minimum vet score (1-10) for issues to keep after vetting? Issues below this are auto-filtered.',
+                current: config.scoreThreshold,
+                default: 6,
+                type: 'number',
+            },
             {
                 setting: 'aiPolicyBlocklist',
                 prompt: 'Repos with anti-AI contribution policies to block (owner/repo, comma-separated)?',

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

@@ -0,0 +1,24 @@
+/**
+ * Vet-list command (#764)
+ * Re-vets all available issues in a curated issue list file.
+ */
+import { type VetListOutput, type VetOutput, type VetListItemStatus } from '../formatters/json.js';
+interface VetListOptions {
+    issueListPath?: string;
+    concurrency?: number;
+}
+/**
+ * Determine the list status from vetting results.
+ * Maps vetting recommendation + reasons to a list-level status.
+ */
+export declare function classifyListStatus(vetResult: VetOutput): VetListItemStatus;
+/**
+ * Re-vet all available issues in a curated issue list.
+ * Reads the list file, extracts available (non-done) issues,
+ * and vets each in parallel with concurrency control.
+ *
+ * @param options - Vet-list options
+ * @returns Consolidated vetting results with list status for each issue
+ */
+export declare function runVetList(options?: VetListOptions): Promise<VetListOutput>;
+export {};

package/dist/commands/vet-list.js

@@ -0,0 +1,112 @@
+/**
+ * Vet-list command (#764)
+ * Re-vets all available issues in a curated issue list file.
+ */
+import { IssueDiscovery, requireGitHubToken } from '../core/index.js';
+import { detectIssueList } from './startup.js';
+/**
+ * Determine the list status from vetting results.
+ * Maps vetting recommendation + reasons to a list-level status.
+ */
+export function classifyListStatus(vetResult) {
+    const skipReasons = vetResult.reasonsToSkip.map((r) => r.toLowerCase());
+    if (skipReasons.some((r) => r.includes('closed')))
+        return 'closed';
+    if (skipReasons.some((r) => r.includes('claimed') || r.includes('assigned')))
+        return 'claimed';
+    if (skipReasons.some((r) => r.includes('existing pr') || r.includes('linked pr') || r.includes('pull request')))
+        return 'has_pr';
+    if (vetResult.recommendation === 'approve' || vetResult.recommendation === 'needs_review') {
+        return 'still_available';
+    }
+    // Default: if skipped for other reasons, still mark as available
+    // (the vetting result will show why it's not recommended)
+    return 'still_available';
+}
+/**
+ * Re-vet all available issues in a curated issue list.
+ * Reads the list file, extracts available (non-done) issues,
+ * and vets each in parallel with concurrency control.
+ *
+ * @param options - Vet-list options
+ * @returns Consolidated vetting results with list status for each issue
+ */
+export async function runVetList(options = {}) {
+    const token = requireGitHubToken();
+    const concurrency = options.concurrency ?? 5;
+    // 1. Find and parse the issue list
+    let issueListPath = options.issueListPath;
+    if (!issueListPath) {
+        const detected = detectIssueList();
+        if (!detected) {
+            throw new Error('No issue list found. Provide a path with --path or configure issueListPath in settings.');
+        }
+        issueListPath = detected.path;
+    }
+    const { runParseList } = await import('./parse-list.js');
+    const parsed = await runParseList({ filePath: issueListPath });
+    if (parsed.available.length === 0) {
+        return {
+            results: [],
+            summary: { total: 0, stillAvailable: 0, claimed: 0, closed: 0, hasPR: 0, errors: 0 },
+        };
+    }
+    // 2. Vet each available issue in parallel with concurrency limit
+    const discovery = new IssueDiscovery(token);
+    const results = [];
+    // Simple concurrency limiter
+    const items = parsed.available;
+    let index = 0;
+    async function processNext() {
+        while (index < items.length) {
+            const item = items[index++];
+            try {
+                const candidate = await discovery.vetIssue(item.url);
+                const vetResult = {
+                    issue: {
+                        repo: candidate.issue.repo,
+                        number: candidate.issue.number,
+                        title: candidate.issue.title,
+                        url: candidate.issue.url,
+                        labels: candidate.issue.labels,
+                    },
+                    recommendation: candidate.recommendation,
+                    reasonsToApprove: candidate.reasonsToApprove,
+                    reasonsToSkip: candidate.reasonsToSkip,
+                    projectHealth: candidate.projectHealth,
+                    vettingResult: candidate.vettingResult,
+                };
+                results.push({
+                    ...vetResult,
+                    listStatus: classifyListStatus(vetResult),
+                });
+            }
+            catch (error) {
+                // Per-issue errors don't fail the batch
+                results.push({
+                    issue: { repo: item.repo, number: item.number, title: item.title, url: item.url, labels: [] },
+                    recommendation: 'skip',
+                    reasonsToApprove: [],
+                    reasonsToSkip: [`Error: ${error instanceof Error ? error.message : String(error)}`],
+                    projectHealth: {},
+                    vettingResult: {},
+                    listStatus: 'error',
+                    errorMessage: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+    }
+    // Start `concurrency` workers
+    const workers = Array.from({ length: Math.min(concurrency, items.length) }, () => processNext());
+    await Promise.all(workers);
+    // 3. Compute summary
+    const summary = {
+        total: results.length,
+        stillAvailable: results.filter((r) => r.listStatus === 'still_available').length,
+        claimed: results.filter((r) => r.listStatus === 'claimed').length,
+        closed: results.filter((r) => r.listStatus === 'closed').length,
+        hasPR: results.filter((r) => r.listStatus === 'has_pr').length,
+        errors: results.filter((r) => r.listStatus === 'error').length,
+    };
+    return { results, summary };
+}

package/dist/core/daily-logic.js

@@ -333,11 +333,25 @@ export function computeActionMenu(actionableIssues, capacity, commentedIssues =
     }
     // The orchestration layer (commands/oss.md Action Menu section) may insert issue-list
     // options before the search item when a curated list is available.
-    items.push({
+    const searchItem = {
         key: 'search',
         label: 'Search for new issues',
         description: 'Look for new contribution opportunities',
-    });
+    };
+    if (!capacity.hasCapacity) {
+        const atLimit = capacity.activePRCount >= capacity.maxActivePRs;
+        const hasCritical = capacity.criticalIssueCount > 0;
+        if (atLimit && hasCritical) {
+            searchItem.capacityWarning = `You're at ${capacity.activePRCount}/${capacity.maxActivePRs} active PRs and have ${capacity.criticalIssueCount} critical issue(s). Resolve existing work before claiming new issues.`;
+        }
+        else if (atLimit) {
+            searchItem.capacityWarning = `You're at ${capacity.activePRCount}/${capacity.maxActivePRs} active PRs. Claiming a new issue will exceed your limit.`;
+        }
+        else {
+            searchItem.capacityWarning = `You have ${capacity.criticalIssueCount} critical issue(s) needing attention. Resolve them before claiming new issues.`;
+        }
+    }
+    items.push(searchItem);
     items.push({
         key: 'done',
         label: 'Done for now',

package/dist/core/state-schema.d.ts

@@ -209,6 +209,7 @@ export declare const AgentConfigSchema: z.ZodObject<{
     trustedProjects: z.ZodDefault<z.ZodArray<z.ZodString>>;
     githubUsername: z.ZodDefault<z.ZodString>;
     minRepoScoreThreshold: z.ZodDefault<z.ZodNumber>;
+    scoreThreshold: z.ZodDefault<z.ZodNumber>;
     starredRepos: z.ZodDefault<z.ZodArray<z.ZodString>>;
     starredReposLastFetched: z.ZodOptional<z.ZodString>;
     showHealthCheck: z.ZodOptional<z.ZodBoolean>;
@@ -354,6 +355,7 @@ export declare const AgentStateSchema: z.ZodObject<{
         trustedProjects: z.ZodDefault<z.ZodArray<z.ZodString>>;
         githubUsername: z.ZodDefault<z.ZodString>;
         minRepoScoreThreshold: z.ZodDefault<z.ZodNumber>;
+        scoreThreshold: z.ZodDefault<z.ZodNumber>;
         starredRepos: z.ZodDefault<z.ZodArray<z.ZodString>>;
         starredReposLastFetched: z.ZodOptional<z.ZodString>;
         showHealthCheck: z.ZodOptional<z.ZodBoolean>;

package/dist/core/state-schema.js

@@ -135,6 +135,7 @@ export const AgentConfigSchema = z.object({
     trustedProjects: z.array(z.string()).default([]),
     githubUsername: z.string().default(''),
     minRepoScoreThreshold: z.number().default(4),
+    scoreThreshold: z.number().int().min(1).max(10).default(6),
     starredRepos: z.array(z.string()).default([]),
     starredReposLastFetched: z.string().optional(),
     showHealthCheck: z.boolean().optional(),

package/dist/formatters/json.d.ts

@@ -53,6 +53,8 @@ export interface ActionMenuItem {
     label: string;
     /** Explanation shown below the label. */
     description: string;
+    /** Present when the action would exceed the user's PR capacity limit (#765). */
+    capacityWarning?: string;
 }
 /**
  * Pre-computed action menu for the orchestration layer.
@@ -111,6 +113,31 @@ export interface DailyOutput {
     repoGroups: CompactRepoGroup[];
     failures: PRCheckFailure[];
 }
+/**
+ * Compact version of DailyOutput for reduced JSON payload size (#763).
+ * Omits `summary` (pre-rendered markdown ~8KB that duplicates structured fields),
+ * `repoGroups` (derivable from digest.openPRs), and full `failures` array.
+ * Retains `commentedIssues` because downstream workflows (review-issue-replies.md,
+ * action-menu.md) consume it directly.
+ * Includes `failureCount` so consumers can detect partial fetch failures without
+ * carrying the full error payload.
+ */
+export interface CompactDailyOutput {
+    digest: DailyDigestCompact;
+    capacity: CapacityAssessment;
+    briefSummary: string;
+    actionableIssues: CompactActionableIssue[];
+    actionMenu: ActionMenu;
+    commentedIssues: CommentedIssue[];
+    /** Number of PRs that failed to fetch. Non-zero indicates partial results. */
+    failureCount: number;
+}
+/**
+ * Strip a full DailyOutput down to the compact subset (#763).
+ * Omits summary, repoGroups, and full failures array. Retains a failureCount
+ * so consumers can detect partial fetch failures.
+ */
+export declare function toCompactDailyOutput(output: DailyOutput): CompactDailyOutput;
 /**
  * Convert a full DailyDigest to the compact format for JSON output (#287).
  * Category arrays become PR URL arrays; full objects stay only in openPRs.
@@ -207,6 +234,19 @@ export interface StartupOutput {
     dashboardUrl?: string;
     issueList?: IssueListInfo;
 }
+/**
+ * Compact version of StartupOutput for reduced JSON payload (#763).
+ * Derived from StartupOutput with CompactDailyOutput substituted for DailyOutput.
+ * Using Omit ensures new fields added to StartupOutput are automatically included.
+ */
+export type CompactStartupOutput = Omit<StartupOutput, 'daily'> & {
+    daily?: CompactDailyOutput;
+};
+/**
+ * Convert a full StartupOutput to the compact format (#763).
+ * Uses destructuring to auto-forward any new fields added to StartupOutput.
+ */
+export declare function toCompactStartupOutput(output: StartupOutput): CompactStartupOutput;
 /** A single parsed issue from a markdown list (#82) */
 export interface ParsedIssueItem {
     repo: string;
@@ -234,6 +274,23 @@ export interface CheckIntegrationOutput {
     newFiles: NewFileInfo[];
     unreferencedCount: number;
 }
+/** Status of a re-vetted issue from the curated list (#764). */
+export type VetListItemStatus = 'still_available' | 'claimed' | 'closed' | 'has_pr' | 'error';
+/** Output of the vet-list command (#764). */
+export interface VetListOutput {
+    results: Array<VetOutput & {
+        listStatus: VetListItemStatus;
+        errorMessage?: string;
+    }>;
+    summary: {
+        total: number;
+        stillAvailable: number;
+        claimed: number;
+        closed: number;
+        hasPR: number;
+        errors: number;
+    };
+}
 /** Output of the vet command */
 export interface VetOutput {
     issue: {

package/dist/formatters/json.js

@@ -2,6 +2,22 @@
  * JSON output formatter for CLI --json mode
  * Provides structured output that can be consumed by scripts and plugins
  */
+/**
+ * Strip a full DailyOutput down to the compact subset (#763).
+ * Omits summary, repoGroups, and full failures array. Retains a failureCount
+ * so consumers can detect partial fetch failures.
+ */
+export function toCompactDailyOutput(output) {
+    return {
+        digest: output.digest,
+        capacity: output.capacity,
+        briefSummary: output.briefSummary,
+        actionableIssues: output.actionableIssues,
+        actionMenu: output.actionMenu,
+        commentedIssues: output.commentedIssues,
+        failureCount: output.failures.length,
+    };
+}
 /**
  * Convert a full DailyDigest to the compact format for JSON output (#287).
  * Category arrays become PR URL arrays; full objects stay only in openPRs.
@@ -43,6 +59,19 @@ export function compactRepoGroups(groups) {
         prUrls: group.prs.map((pr) => pr.url),
     }));
 }
+/**
+ * Convert a full StartupOutput to the compact format (#763).
+ * Uses destructuring to auto-forward any new fields added to StartupOutput.
+ */
+export function toCompactStartupOutput(output) {
+    const { daily, ...rest } = output;
+    return {
+        ...rest,
+        daily: daily ? toCompactDailyOutput(daily) : undefined,
+        dashboardUrl: output.dashboardUrl,
+        issueList: output.issueList,
+    };
+}
 /**
  * Wrap data in a standard JSON output envelope
  */

package/package.json

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