@oss-autopilot/core 0.43.0 → 0.43.1

package/dist/commands/config.js

@@ -3,6 +3,7 @@
  * Shows or updates configuration
  */
 import { getStateManager } from '../core/index.js';
+import { validateGitHubUsername } from './validation.js';
 export async function runConfig(options) {
     const stateManager = getStateManager();
     const currentConfig = stateManager.getState().config;
@@ -17,7 +18,7 @@ export async function runConfig(options) {
     // Handle specific config keys
     switch (options.key) {
         case 'username':
-            stateManager.updateConfig({ githubUsername: value });
+            stateManager.updateConfig({ githubUsername: validateGitHubUsername(value) });
             break;
         case 'add-language':
             if (!currentConfig.languages.includes(value)) {

package/dist/commands/daily.js

@@ -7,9 +7,22 @@
  * orchestration layer that wires up the phases and handles I/O.
  */
 import { getStateManager, PRMonitor, IssueConversationMonitor, requireGitHubToken, CRITICAL_STATUSES, computeRepoSignals, groupPRsByRepo, assessCapacity, collectActionableIssues, computeActionMenu, toShelvedPRRef, formatBriefSummary, formatSummary, } from '../core/index.js';
-import { errorMessage } from '../core/errors.js';
+import { errorMessage, getHttpStatusCode } from '../core/errors.js';
+import { warn } from '../core/logger.js';
 import { emptyPRCountsResult } from '../core/github-stats.js';
 import { deduplicateDigest, compactActionableIssues, compactRepoGroups, } from '../formatters/json.js';
+const MODULE = 'daily';
+/** Return true for errors that should propagate (not degrade gracefully). */
+function isRateLimitOrAuthError(err) {
+    const status = getHttpStatusCode(err);
+    if (status === 401 || status === 429)
+        return true;
+    if (status === 403) {
+        const msg = errorMessage(err).toLowerCase();
+        return msg.includes('rate limit') || msg.includes('abuse detection');
+    }
+    return false;
+}
 // Re-export domain functions so existing consumers (tests, dashboard, startup)
 // can continue importing from './daily.js' without changes.
 export { computeRepoSignals, groupPRsByRepo, assessCapacity, collectActionableIssues, computeActionMenu, toShelvedPRRef, formatBriefSummary, formatSummary, printDigest, CRITICAL_STATUSES, } from '../core/index.js';
@@ -26,35 +39,45 @@ async function fetchPRData(prMonitor, token) {
     const { prs, failures } = await prMonitor.fetchUserOpenPRs();
     // Log any failures (but continue with successful checks)
     if (failures.length > 0) {
-        console.error(`Warning: ${failures.length} PR fetch(es) failed`);
+        warn(MODULE, `${failures.length} PR fetch(es) failed`);
     }
     // Fetch merged PR counts, closed PR counts, recently closed PRs, recently merged PRs, and commented issues in parallel
     // All stats fetches are non-critical (cosmetic/scoring), so isolate their failure
     const issueMonitor = new IssueConversationMonitor(token);
     const [mergedResult, closedResult, recentlyClosedPRs, recentlyMergedPRs, issueConversationResult] = await Promise.all([
         prMonitor.fetchUserMergedPRCounts().catch((err) => {
-            console.error(`Warning: Failed to fetch merged PR counts: ${errorMessage(err)}`);
+            if (isRateLimitOrAuthError(err))
+                throw err;
+            warn(MODULE, `Failed to fetch merged PR counts: ${errorMessage(err)}`);
             return emptyPRCountsResult();
         }),
         prMonitor.fetchUserClosedPRCounts().catch((err) => {
-            console.error(`Warning: Failed to fetch closed PR counts: ${errorMessage(err)}`);
+            if (isRateLimitOrAuthError(err))
+                throw err;
+            warn(MODULE, `Failed to fetch closed PR counts: ${errorMessage(err)}`);
             return emptyPRCountsResult();
         }),
         prMonitor.fetchRecentlyClosedPRs().catch((err) => {
-            console.error(`Warning: Failed to fetch recently closed PRs: ${errorMessage(err)}`);
+            if (isRateLimitOrAuthError(err))
+                throw err;
+            warn(MODULE, `Failed to fetch recently closed PRs: ${errorMessage(err)}`);
             return [];
         }),
         prMonitor.fetchRecentlyMergedPRs().catch((err) => {
-            console.error(`Warning: Failed to fetch recently merged PRs: ${errorMessage(err)}`);
+            if (isRateLimitOrAuthError(err))
+                throw err;
+            warn(MODULE, `Failed to fetch recently merged PRs: ${errorMessage(err)}`);
             return [];
         }),
         issueMonitor.fetchCommentedIssues().catch((error) => {
+            if (isRateLimitOrAuthError(error))
+                throw error;
             const msg = errorMessage(error);
             if (msg.includes('No GitHub username configured')) {
-                console.error(`[DAILY] Issue conversation tracking requires setup: ${msg}`);
+                warn(MODULE, `Issue conversation tracking requires setup: ${msg}`);
             }
             else {
-                console.error(`[DAILY] Issue conversation fetch failed: ${msg}`);
+                warn(MODULE, `Issue conversation fetch failed: ${msg}`);
             }
             return {
                 issues: [],
@@ -64,7 +87,7 @@ async function fetchPRData(prMonitor, token) {
     ]);
     const commentedIssues = issueConversationResult.issues;
     if (issueConversationResult.failures.length > 0) {
-        console.error(`[DAILY] ${issueConversationResult.failures.length} issue conversation check(s) failed`);
+        warn(MODULE, `${issueConversationResult.failures.length} issue conversation check(s) failed`);
     }
     const { repos: mergedCounts, monthlyCounts, monthlyOpenedCounts: openedFromMerged } = mergedResult;
     const { repos: closedCounts, monthlyCounts: monthlyClosedCounts, monthlyOpenedCounts: openedFromClosed, } = closedResult;
@@ -94,7 +117,7 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
     // skip the reset to avoid wiping scores due to transient API failures.
     const existingReposWithMerges = Object.values(stateManager.getState().repoScores).filter((s) => s.mergedPRCount > 0);
     if (mergedCounts.size === 0 && existingReposWithMerges.length > 0) {
-        console.error(`[DAILY] Skipping stale repo reset: API returned 0 merged PR results but state has ${existingReposWithMerges.length} repo(s) with merges. Possible API issue.`);
+        warn(MODULE, `Skipping stale repo reset: API returned 0 merged PR results but state has ${existingReposWithMerges.length} repo(s) with merges. Possible API issue.`);
     }
     else {
         for (const score of Object.values(stateManager.getState().repoScores)) {
@@ -111,18 +134,18 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
         }
         catch (error) {
             mergedCountFailures++;
-            console.error(`[DAILY] Failed to update merged count for ${repo}:`, errorMessage(error));
+            warn(MODULE, `Failed to update merged count for ${repo}: ${errorMessage(error)}`);
         }
     }
     if (mergedCountFailures === mergedCounts.size && mergedCounts.size > 0) {
-        console.error(`[DAILY_ALL_MERGED_COUNT_UPDATES_FAILED] All ${mergedCounts.size} merged count update(s) failed.`);
+        warn(MODULE, `[ALL_MERGED_COUNT_UPDATES_FAILED] All ${mergedCounts.size} merged count update(s) failed.`);
     }
     // Populate closedWithoutMergeCount in repo scores.
     // Diagnostic: warn if API returned empty but we have known closed PRs (possible transient API failure).
     // Unlike merged counts above, there is no stale-reset loop for closed counts, so no skip is needed.
     const existingReposWithClosed = Object.values(stateManager.getState().repoScores).filter((s) => (s.closedWithoutMergeCount || 0) > 0);
     if (closedCounts.size === 0 && existingReposWithClosed.length > 0) {
-        console.error(`[DAILY] Warning: API returned 0 closed PR results but state has ${existingReposWithClosed.length} repo(s) with closed PRs. Possible transient API issue.`);
+        warn(MODULE, `API returned 0 closed PR results but state has ${existingReposWithClosed.length} repo(s) with closed PRs. Possible transient API issue.`);
     }
     let closedCountFailures = 0;
     for (const [repo, count] of closedCounts) {
@@ -131,11 +154,11 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
         }
         catch (error) {
             closedCountFailures++;
-            console.error(`[DAILY] Failed to update closed count for ${repo}:`, errorMessage(error));
+            warn(MODULE, `Failed to update closed count for ${repo}: ${errorMessage(error)}`);
         }
     }
     if (closedCountFailures === closedCounts.size && closedCounts.size > 0) {
-        console.error(`[DAILY_ALL_CLOSED_COUNT_UPDATES_FAILED] All ${closedCounts.size} closed count update(s) failed.`);
+        warn(MODULE, `[ALL_CLOSED_COUNT_UPDATES_FAILED] All ${closedCounts.size} closed count update(s) failed.`);
     }
     // Update repo signals from observed open PR data (responsiveness, active maintainers).
     // Only repos with current open PRs get signal updates — repos with no open PRs
@@ -150,11 +173,11 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
         }
         catch (error) {
             signalUpdateFailures++;
-            console.error(`[DAILY] Failed to update signals for ${repo}:`, errorMessage(error));
+            warn(MODULE, `Failed to update signals for ${repo}: ${errorMessage(error)}`);
         }
     }
     if (signalUpdateFailures === repoSignals.size && repoSignals.size > 0) {
-        console.error(`[DAILY_ALL_SIGNAL_UPDATES_FAILED] All ${repoSignals.size} signal update(s) failed. This may indicate corrupted state.`);
+        warn(MODULE, `[ALL_SIGNAL_UPDATES_FAILED] All ${repoSignals.size} signal update(s) failed. This may indicate corrupted state.`);
     }
     // Fetch star counts for all scored repos (used by dashboard minStars filter, #216)
     const allRepos = Object.keys(stateManager.getState().repoScores);
@@ -163,8 +186,8 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
         starCounts = await prMonitor.fetchRepoStarCounts(allRepos);
     }
     catch (error) {
-        console.error('[DAILY] Failed to fetch repo star counts:', errorMessage(error));
-        console.error('[DAILY] Dashboard minStars filter will use cached star counts (or be skipped for repos without cached data).');
+        warn(MODULE, `Failed to fetch repo star counts: ${errorMessage(error)}`);
+        warn(MODULE, 'Dashboard minStars filter will use cached star counts (or be skipped for repos without cached data).');
         starCounts = new Map();
     }
     let starUpdateFailures = 0;
@@ -174,11 +197,11 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
         }
         catch (error) {
             starUpdateFailures++;
-            console.error(`[DAILY] Failed to update star count for ${repo}:`, errorMessage(error));
+            warn(MODULE, `Failed to update star count for ${repo}: ${errorMessage(error)}`);
         }
     }
     if (starUpdateFailures === starCounts.size && starCounts.size > 0) {
-        console.error(`[DAILY_ALL_STAR_COUNT_UPDATES_FAILED] All ${starCounts.size} star count update(s) failed.`);
+        warn(MODULE, `[ALL_STAR_COUNT_UPDATES_FAILED] All ${starCounts.size} star count update(s) failed.`);
     }
     // Auto-sync trustedProjects from repos with merged PRs
     let trustSyncFailures = 0;
@@ -188,11 +211,11 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
         }
         catch (error) {
             trustSyncFailures++;
-            console.error(`[DAILY] Failed to sync trusted project ${repo}:`, errorMessage(error));
+            warn(MODULE, `Failed to sync trusted project ${repo}: ${errorMessage(error)}`);
         }
     }
     if (trustSyncFailures === mergedCounts.size && mergedCounts.size > 0) {
-        console.error(`[DAILY_ALL_TRUST_SYNCS_FAILED] All ${mergedCounts.size} trusted project sync(s) failed. This may indicate corrupted state.`);
+        warn(MODULE, `[ALL_TRUST_SYNCS_FAILED] All ${mergedCounts.size} trusted project sync(s) failed. This may indicate corrupted state.`);
     }
 }
 /**
@@ -211,7 +234,7 @@ function updateAnalytics(prs, monthlyCounts, monthlyClosedCounts, openedFromMerg
         }
     }
     catch (error) {
-        console.error('[DAILY] Failed to store monthly merged counts:', errorMessage(error));
+        warn(MODULE, `Failed to store monthly merged counts: ${errorMessage(error)}`);
     }
     try {
         if (Object.keys(monthlyClosedCounts).length > 0) {
@@ -219,7 +242,7 @@ function updateAnalytics(prs, monthlyCounts, monthlyClosedCounts, openedFromMerg
         }
     }
     catch (error) {
-        console.error('[DAILY] Failed to store monthly closed counts:', errorMessage(error));
+        warn(MODULE, `Failed to store monthly closed counts: ${errorMessage(error)}`);
     }
     try {
         // Build combined monthly opened counts from merged + closed + currently-open PRs
@@ -239,7 +262,7 @@ function updateAnalytics(prs, monthlyCounts, monthlyClosedCounts, openedFromMerg
         }
     }
     catch (error) {
-        console.error('[DAILY] Failed to compute/store monthly opened counts:', errorMessage(error));
+        warn(MODULE, `Failed to compute/store monthly opened counts: ${errorMessage(error)}`);
     }
 }
 /**
@@ -254,15 +277,13 @@ function partitionPRs(prMonitor, prs, recentlyClosedPRs, recentlyMergedPRs) {
     try {
         const expiredSnoozes = stateManager.expireSnoozes();
         if (expiredSnoozes.length > 0) {
-            console.error(`[DAILY] ${expiredSnoozes.length} snoozed PR(s) expired and will resurface:`);
-            for (const url of expiredSnoozes) {
-                console.error(`  - ${url}`);
-            }
+            const urls = expiredSnoozes.map((url) => `  - ${url}`).join('\n');
+            warn(MODULE, `${expiredSnoozes.length} snoozed PR(s) expired and will resurface:\n${urls}`);
             stateManager.save();
         }
     }
     catch (error) {
-        console.error('[DAILY] Failed to expire/persist snoozes:', errorMessage(error));
+        warn(MODULE, `Failed to expire/persist snoozes: ${errorMessage(error)}`);
     }
     // Partition PRs into active vs shelved, auto-unshelving when maintainers engage
     const shelvedPRs = [];
@@ -322,12 +343,12 @@ function generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, fa
             if (isNaN(responseTime) || isNaN(dismissTime)) {
                 // Invalid timestamp — fail open (include issue to be safe) without
                 // permanently removing dismiss record (may be a transient data issue)
-                console.error(`[DAILY] Invalid timestamp in dismiss check for ${issue.url}, including issue`);
+                warn(MODULE, `Invalid timestamp in dismiss check for ${issue.url}, including issue`);
                 return true;
             }
             if (responseTime > dismissTime) {
                 // New activity after dismiss — auto-undismiss and resurface
-                console.error(`[DAILY] Auto-undismissing issue ${issue.url}: new response at ${issue.lastResponseAt} after dismiss at ${dismissedAt}`);
+                warn(MODULE, `Auto-undismissing issue ${issue.url}: new response at ${issue.lastResponseAt} after dismiss at ${dismissedAt}`);
                 stateManager.undismissIssue(issue.url);
                 hasAutoUndismissed = true;
                 return true;
@@ -349,12 +370,12 @@ function generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, fa
         if (isNaN(activityTime) || isNaN(dismissTime)) {
             // Invalid timestamp — fail open (include PR to be safe) without
             // permanently removing dismiss record (may be a transient data issue)
-            console.error(`[DAILY] Invalid timestamp in PR dismiss check for ${pr.url}, including PR`);
+            warn(MODULE, `Invalid timestamp in PR dismiss check for ${pr.url}, including PR`);
             return true;
         }
         if (activityTime > dismissTime) {
             // New activity after dismiss — auto-undismiss and resurface
-            console.error(`[DAILY] Auto-undismissing PR ${pr.url}: new activity at ${pr.updatedAt} after dismiss at ${dismissedAt}`);
+            warn(MODULE, `Auto-undismissing PR ${pr.url}: new activity at ${pr.updatedAt} after dismiss at ${dismissedAt}`);
             stateManager.undismissIssue(pr.url);
             hasAutoUndismissed = true;
             return true;
@@ -368,7 +389,7 @@ function generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, fa
             stateManager.save();
         }
         catch (error) {
-            console.error('[DAILY] Failed to persist auto-undismissed state:', errorMessage(error));
+            warn(MODULE, `Failed to persist auto-undismissed state: ${errorMessage(error)}`);
         }
     }
     const actionableIssues = collectActionableIssues(nonDismissedPRs, snoozedUrls);

package/dist/commands/dashboard-server.js

@@ -114,7 +114,7 @@ export async function findRunningDashboardServer() {
 function buildDashboardJson(digest, state, commentedIssues) {
     const prsByRepo = computePRsByRepo(digest, state);
     const topRepos = computeTopRepos(prsByRepo);
-    const { monthlyMerged } = getMonthlyData(state);
+    const { monthlyMerged, monthlyOpened, monthlyClosed } = getMonthlyData(state);
     const stats = buildDashboardStats(digest, state);
     const issueResponses = commentedIssues.filter((i) => i.status === 'new_response');
     return {
@@ -122,6 +122,8 @@ function buildDashboardJson(digest, state, commentedIssues) {
         prsByRepo,
         topRepos: topRepos.map(([repo, data]) => ({ repo, ...data })),
         monthlyMerged,
+        monthlyOpened,
+        monthlyClosed,
         activePRs: digest.openPRs || [],
         shelvedPRUrls: state.config.shelvedPRUrls || [],
         commentedIssues,

package/dist/commands/startup.js

@@ -8,8 +8,9 @@
  */
 import * as fs from 'fs';
 import { execFile } from 'child_process';
-import { getStateManager, getGitHubToken, getCLIVersion } from '../core/index.js';
+import { getStateManager, getGitHubToken, getCLIVersion, getStatePath, getDashboardPath } from '../core/index.js';
 import { errorMessage } from '../core/errors.js';
+import { warn } from '../core/logger.js';
 import { executeDailyCheck } from './daily.js';
 import { writeDashboardFromState } from './dashboard.js';
 import { launchDashboardServer } from './dashboard-lifecycle.js';
@@ -116,6 +117,25 @@ function openInBrowser(filePath) {
         }
     });
 }
+/**
+ * Check whether the dashboard HTML file is at least as recent as state.json.
+ * Returns true when the dashboard exists and its mtime >= state mtime,
+ * meaning there is no need to regenerate it.
+ */
+function isDashboardFresh() {
+    try {
+        const dashPath = getDashboardPath();
+        if (!fs.existsSync(dashPath))
+            return false;
+        const dashMtime = fs.statSync(dashPath).mtimeMs;
+        const stateMtime = fs.statSync(getStatePath()).mtimeMs;
+        return dashMtime >= stateMtime;
+    }
+    catch (error) {
+        warn('startup', `Failed to check dashboard freshness, will regenerate: ${errorMessage(error)}`);
+        return false;
+    }
+}
 /**
  * Run startup checks and return structured output.
  * Returns StartupOutput with one of three shapes:
@@ -143,10 +163,17 @@ export async function runStartup() {
     }
     // 3. Run daily check
     const daily = await executeDailyCheck(token);
-    // 4. Generate static HTML dashboard (always — serves as fallback + snapshot)
+    // 4. Generate static HTML dashboard (serves as fallback + snapshot).
+    //    Skip regeneration if the dashboard HTML is already newer than state.json.
     let dashboardPath;
     try {
-        dashboardPath = writeDashboardFromState();
+        if (isDashboardFresh()) {
+            dashboardPath = getDashboardPath();
+            console.error('[STARTUP] Dashboard HTML is fresh, skipping regeneration');
+        }
+        else {
+            dashboardPath = writeDashboardFromState();
+        }
     }
     catch (error) {
         console.error('[STARTUP] Dashboard generation failed:', errorMessage(error));

package/dist/commands/vet.js

@@ -3,9 +3,10 @@
  * Vets a specific issue before working on it
  */
 import { IssueDiscovery, requireGitHubToken } from '../core/index.js';
-import { validateUrl } from './validation.js';
+import { ISSUE_URL_PATTERN, validateGitHubUrl, validateUrl } from './validation.js';
 export async function runVet(options) {
     validateUrl(options.issueUrl);
+    validateGitHubUrl(options.issueUrl, ISSUE_URL_PATTERN, 'issue');
     const token = requireGitHubToken();
     const discovery = new IssueDiscovery(token);
     const candidate = await discovery.vetIssue(options.issueUrl);

package/dist/core/concurrency.d.ts

@@ -1,5 +1,6 @@
 /**
  * Runs a worker pool that processes items with bounded concurrency.
- * N workers consume from a shared index — simpler than Promise.race + splice.
+ * N workers consume from a shared index. On any worker error, remaining
+ * workers are aborted via a shared flag and the error is propagated.
  */
 export declare function runWorkerPool<T>(items: T[], worker: (item: T) => Promise<void>, concurrency: number): Promise<void>;

package/dist/core/concurrency.js

@@ -1,13 +1,23 @@
 /**
  * Runs a worker pool that processes items with bounded concurrency.
- * N workers consume from a shared index — simpler than Promise.race + splice.
+ * N workers consume from a shared index. On any worker error, remaining
+ * workers are aborted via a shared flag and the error is propagated.
  */
 export async function runWorkerPool(items, worker, concurrency) {
     let index = 0;
+    let aborted = false;
     const poolWorker = async () => {
         while (index < items.length) {
+            if (aborted)
+                break;
             const item = items[index++];
-            await worker(item);
+            try {
+                await worker(item);
+            }
+            catch (err) {
+                aborted = true;
+                throw err;
+            }
         }
     };
     const workerCount = Math.min(concurrency, items.length);

package/dist/core/pr-monitor.js

@@ -350,11 +350,7 @@ export class PRMonitor {
      * Check if PR has merge conflict
      */
     hasMergeConflict(mergeable, mergeableState) {
-        if (mergeable === false)
-            return true;
-        if (mergeableState === 'dirty')
-            return true;
-        return false;
+        return mergeable === false || mergeableState === 'dirty';
     }
     /**
      * Get CI status from combined status API and check runs.
@@ -371,6 +367,14 @@ export class PRMonitor {
                 // 404 is expected for repos without check runs configured; log other errors for debugging
                 this.octokit.checks.listForRef({ owner, repo, ref: sha }).catch((err) => {
                     const status = getHttpStatusCode(err);
+                    // Rate limit errors must propagate — matches listReviewComments pattern (#481)
+                    if (status === 429)
+                        throw err;
+                    if (status === 403) {
+                        const msg = errorMessage(err).toLowerCase();
+                        if (msg.includes('rate limit') || msg.includes('abuse detection'))
+                            throw err;
+                    }
                     if (status === 404) {
                         debug('pr-monitor', `Check runs 404 for ${owner}/${repo}@${sha.slice(0, 7)} (no checks configured)`);
                     }
@@ -400,12 +404,8 @@ export class PRMonitor {
         }
         catch (error) {
             const statusCode = getHttpStatusCode(error);
-            const errMsg = errorMessage(error);
-            if (statusCode === 401) {
-                warn('pr-monitor', `CI check failed for ${owner}/${repo}: Invalid token`);
-            }
-            else if (statusCode === 403) {
-                warn('pr-monitor', `CI check failed for ${owner}/${repo}: Rate limit exceeded`);
+            if (statusCode === 401 || statusCode === 403 || statusCode === 429) {
+                throw error;
             }
             else if (statusCode === 404) {
                 // Repo might not have CI configured, this is normal
@@ -413,7 +413,7 @@ export class PRMonitor {
                 return { status: 'unknown', failingCheckNames: [], failingCheckConclusions: new Map() };
             }
             else {
-                warn('pr-monitor', `Failed to check CI for ${owner}/${repo}@${sha.slice(0, 7)}: ${errMsg}`);
+                warn('pr-monitor', `Failed to check CI for ${owner}/${repo}@${sha.slice(0, 7)}: ${errorMessage(error)}`);
             }
             return { status: 'unknown', failingCheckNames: [], failingCheckConclusions: new Map() };
         }

package/dist/core/utils.d.ts

@@ -144,10 +144,9 @@ export declare function daysBetween(from: Date, to?: Date): number;
 /**
  * Splits an `"owner/repo"` string into its owner and repo components.
  *
- * Does not validate the input format; if no `/` is present, `repo` will be `undefined`.
- *
  * @param repoFullName - Full repository name in `"owner/repo"` format
  * @returns Object with `owner` and `repo` string properties
+ * @throws {Error} If the input does not contain both an owner and repo separated by `/`
  *
  * @example
  * splitRepo('facebook/react')

package/dist/core/utils.js

@@ -215,10 +215,9 @@ export function daysBetween(from, to = new Date()) {
 /**
  * Splits an `"owner/repo"` string into its owner and repo components.
  *
- * Does not validate the input format; if no `/` is present, `repo` will be `undefined`.
- *
  * @param repoFullName - Full repository name in `"owner/repo"` format
  * @returns Object with `owner` and `repo` string properties
+ * @throws {Error} If the input does not contain both an owner and repo separated by `/`
  *
  * @example
  * splitRepo('facebook/react')
@@ -226,6 +225,9 @@ export function daysBetween(from, to = new Date()) {
  */
 export function splitRepo(repoFullName) {
     const [owner, repo] = repoFullName.split('/');
+    if (!owner || !repo) {
+        throw new Error(`Invalid repo format: expected "owner/repo", got "${repoFullName}"`);
+    }
     return { owner, repo };
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oss-autopilot/core",
-  "version": "0.43.0",
+  "version": "0.43.1",
   "description": "CLI and core library for managing open source contributions",
   "type": "module",
   "bin": {
@@ -60,7 +60,7 @@
   },
   "scripts": {
     "build": "tsc",
-    "bundle": "esbuild src/cli.ts --bundle --platform=node --target=node20 --format=cjs --outfile=dist/cli.bundle.cjs",
+    "bundle": "esbuild src/cli.ts --bundle --platform=node --target=node20 --format=cjs --minify --outfile=dist/cli.bundle.cjs",
     "start": "tsx src/cli.ts",
     "dev": "tsx watch src/cli.ts",
     "typecheck": "tsc --noEmit",