@oss-scout/core 0.2.0 → 0.2.1

package/dist/core/repo-health.js

@@ -4,11 +4,11 @@
  * Extracted from issue-vetting.ts to isolate repo-level checks
  * from issue-level eligibility logic.
  */
-import { daysBetween } from './utils.js';
-import { errorMessage } from './errors.js';
-import { warn } from './logger.js';
-import { getHttpCache, cachedRequest, cachedTimeBased } from './http-cache.js';
-const MODULE = 'repo-health';
+import { daysBetween } from "./utils.js";
+import { errorMessage } from "./errors.js";
+import { warn } from "./logger.js";
+import { getHttpCache, cachedRequest, cachedTimeBased } from "./http-cache.js";
+const MODULE = "repo-health";
 // ── Cache for contribution guidelines ──
 const guidelinesCache = new Map();
 /** TTL for cached contribution guidelines (1 hour). */
@@ -57,7 +57,7 @@ export async function checkProjectHealth(octokit, owner, repo) {
             const lastCommit = commits[0];
             const lastCommitAt = lastCommit?.commit?.author?.date || repoData.pushed_at;
             const daysSinceLastCommit = daysBetween(new Date(lastCommitAt));
-            const ciStatus = 'unknown';
+            const ciStatus = "unknown";
             return {
                 repo: `${owner}/${repo}`,
                 lastCommitAt,
@@ -77,11 +77,11 @@ export async function checkProjectHealth(octokit, owner, repo) {
         warn(MODULE, `Error checking project health for ${owner}/${repo}: ${errMsg}`);
         return {
             repo: `${owner}/${repo}`,
-            lastCommitAt: '',
+            lastCommitAt: "",
             daysSinceLastCommit: 999,
             openIssuesCount: 0,
             avgIssueResponseDays: 0,
-            ciStatus: 'unknown',
+            ciStatus: "unknown",
             isActive: false,
             checkFailed: true,
             failureReason: errMsg,
@@ -101,31 +101,41 @@ export async function fetchContributionGuidelines(octokit, owner, repo) {
     if (cached && Date.now() - cached.fetchedAt < CACHE_TTL_MS) {
         return cached.guidelines;
     }
-    const filesToCheck = ['CONTRIBUTING.md', '.github/CONTRIBUTING.md', 'docs/CONTRIBUTING.md', 'contributing.md'];
+    const filesToCheck = [
+        "CONTRIBUTING.md",
+        ".github/CONTRIBUTING.md",
+        "docs/CONTRIBUTING.md",
+        "contributing.md",
+    ];
     // Probe all paths in parallel — take the first success in priority order
     const results = await Promise.allSettled(filesToCheck.map((file) => octokit.repos.getContent({ owner, repo, path: file }).then(({ data }) => {
-        if ('content' in data) {
-            return Buffer.from(data.content, 'base64').toString('utf-8');
+        if ("content" in data) {
+            return Buffer.from(data.content, "base64").toString("utf-8");
         }
         return null;
     })));
     for (let i = 0; i < results.length; i++) {
         const result = results[i];
-        if (result.status === 'fulfilled' && result.value) {
+        if (result.status === "fulfilled" && result.value) {
             const guidelines = parseContributionGuidelines(result.value);
             guidelinesCache.set(cacheKey, { guidelines, fetchedAt: Date.now() });
             pruneCache();
             return guidelines;
         }
-        if (result.status === 'rejected') {
-            const msg = result.reason instanceof Error ? result.reason.message : String(result.reason);
-            if (!msg.includes('404') && !msg.includes('Not Found')) {
+        if (result.status === "rejected") {
+            const msg = result.reason instanceof Error
+                ? result.reason.message
+                : String(result.reason);
+            if (!msg.includes("404") && !msg.includes("Not Found")) {
                 warn(MODULE, `Unexpected error fetching ${filesToCheck[i]} from ${owner}/${repo}: ${msg}`);
             }
         }
     }
     // Cache the negative result too and prune if needed
-    guidelinesCache.set(cacheKey, { guidelines: undefined, fetchedAt: Date.now() });
+    guidelinesCache.set(cacheKey, {
+        guidelines: undefined,
+        fetchedAt: Date.now(),
+    });
     pruneCache();
     return undefined;
 }
@@ -139,40 +149,41 @@ function parseContributionGuidelines(content) {
     };
     const lowerContent = content.toLowerCase();
     // Detect branch naming conventions
-    if (lowerContent.includes('branch')) {
+    if (lowerContent.includes("branch")) {
         const branchMatch = content.match(/branch[^\n]*(?:named?|format|convention)[^\n]*[`"]([^`"]+)[`"]/i);
         if (branchMatch) {
             guidelines.branchNamingConvention = branchMatch[1];
         }
     }
     // Detect commit message format
-    if (lowerContent.includes('conventional commit')) {
-        guidelines.commitMessageFormat = 'conventional commits';
+    if (lowerContent.includes("conventional commit")) {
+        guidelines.commitMessageFormat = "conventional commits";
     }
-    else if (lowerContent.includes('commit message')) {
+    else if (lowerContent.includes("commit message")) {
         const commitMatch = content.match(/commit message[^\n]*[`"]([^`"]+)[`"]/i);
         if (commitMatch) {
             guidelines.commitMessageFormat = commitMatch[1];
         }
     }
     // Detect test framework
-    if (lowerContent.includes('jest'))
-        guidelines.testFramework = 'Jest';
-    else if (lowerContent.includes('rspec'))
-        guidelines.testFramework = 'RSpec';
-    else if (lowerContent.includes('pytest'))
-        guidelines.testFramework = 'pytest';
-    else if (lowerContent.includes('mocha'))
-        guidelines.testFramework = 'Mocha';
+    if (lowerContent.includes("jest"))
+        guidelines.testFramework = "Jest";
+    else if (lowerContent.includes("rspec"))
+        guidelines.testFramework = "RSpec";
+    else if (lowerContent.includes("pytest"))
+        guidelines.testFramework = "pytest";
+    else if (lowerContent.includes("mocha"))
+        guidelines.testFramework = "Mocha";
     // Detect linter
-    if (lowerContent.includes('eslint'))
-        guidelines.linter = 'ESLint';
-    else if (lowerContent.includes('rubocop'))
-        guidelines.linter = 'RuboCop';
-    else if (lowerContent.includes('prettier'))
-        guidelines.formatter = 'Prettier';
+    if (lowerContent.includes("eslint"))
+        guidelines.linter = "ESLint";
+    else if (lowerContent.includes("rubocop"))
+        guidelines.linter = "RuboCop";
+    else if (lowerContent.includes("prettier"))
+        guidelines.formatter = "Prettier";
     // Detect CLA requirement
-    if (lowerContent.includes('cla') || lowerContent.includes('contributor license agreement')) {
+    if (lowerContent.includes("cla") ||
+        lowerContent.includes("contributor license agreement")) {
         guidelines.claRequired = true;
     }
     return guidelines;

package/dist/core/schemas.d.ts

@@ -4,7 +4,7 @@
  * This file is the single source of truth for persisted type shapes.
  * Types are inferred via `z.infer<>` at the bottom.
  */
-import { z } from 'zod';
+import { z } from "zod";
 export declare const IssueStatusSchema: z.ZodEnum<{
     candidate: "candidate";
     claimed: "claimed";

package/dist/core/schemas.js

@@ -4,21 +4,43 @@
  * This file is the single source of truth for persisted type shapes.
  * Types are inferred via `z.infer<>` at the bottom.
  */
-import { z } from 'zod';
+import { z } from "zod";
 // ── Enum schemas ────────────────────────────────────────────────────
-export const IssueStatusSchema = z.enum(['candidate', 'claimed', 'in_progress', 'pr_submitted']);
+export const IssueStatusSchema = z.enum([
+    "candidate",
+    "claimed",
+    "in_progress",
+    "pr_submitted",
+]);
 export const ProjectCategorySchema = z.enum([
-    'nonprofit',
-    'devtools',
-    'infrastructure',
-    'web-frameworks',
-    'data-ml',
-    'education',
+    "nonprofit",
+    "devtools",
+    "infrastructure",
+    "web-frameworks",
+    "data-ml",
+    "education",
+]);
+export const IssueScopeSchema = z.enum([
+    "beginner",
+    "intermediate",
+    "advanced",
+]);
+export const SearchStrategySchema = z.enum([
+    "merged",
+    "orgs",
+    "starred",
+    "broad",
+    "maintained",
+    "all",
 ]);
-export const IssueScopeSchema = z.enum(['beginner', 'intermediate', 'advanced']);
-export const SearchStrategySchema = z.enum(['merged', 'orgs', 'starred', 'broad', 'maintained', 'all']);
 /** All concrete strategies (excludes 'all' meta-strategy). */
-export const CONCRETE_STRATEGIES = ['merged', 'orgs', 'starred', 'broad', 'maintained'];
+export const CONCRETE_STRATEGIES = [
+    "merged",
+    "orgs",
+    "starred",
+    "broad",
+    "maintained",
+];
 // ── Leaf schemas ────────────────────────────────────────────────────
 export const RepoSignalsSchema = z.object({
     hasActiveMaintainers: z.boolean(),
@@ -96,7 +118,7 @@ export const SavedCandidateSchema = z.object({
     number: z.number(),
     title: z.string(),
     labels: z.array(z.string()),
-    recommendation: z.enum(['approve', 'skip', 'needs_review']),
+    recommendation: z.enum(["approve", "skip", "needs_review"]),
     viabilityScore: z.number(),
     searchPriority: z.string(),
     firstSeenAt: z.string(),
@@ -104,22 +126,22 @@ export const SavedCandidateSchema = z.object({
     lastScore: z.number(),
 });
 // ── Scout preferences schema ────────────────────────────────────────
-export const PersistenceModeSchema = z.enum(['local', 'gist']);
+export const PersistenceModeSchema = z.enum(["local", "gist"]);
 export const ScoutPreferencesSchema = z.object({
-    githubUsername: z.string().default(''),
-    languages: z.array(z.string()).default(['typescript', 'javascript']),
-    labels: z.array(z.string()).default(['good first issue', 'help wanted']),
+    githubUsername: z.string().default(""),
+    languages: z.array(z.string()).default(["typescript", "javascript"]),
+    labels: z.array(z.string()).default(["good first issue", "help wanted"]),
     scope: z.array(IssueScopeSchema).optional(),
     excludeRepos: z.array(z.string()).default([]),
     excludeOrgs: z.array(z.string()).default([]),
-    aiPolicyBlocklist: z.array(z.string()).default(['matplotlib/matplotlib']),
+    aiPolicyBlocklist: z.array(z.string()).default(["matplotlib/matplotlib"]),
     preferredOrgs: z.array(z.string()).default([]),
     projectCategories: z.array(ProjectCategorySchema).default([]),
     minStars: z.number().default(50),
     maxIssueAgeDays: z.number().default(90),
     includeDocIssues: z.boolean().default(true),
     minRepoScoreThreshold: z.number().default(4),
-    persistence: PersistenceModeSchema.default('local'),
+    persistence: PersistenceModeSchema.default("local"),
     defaultStrategy: z.array(SearchStrategySchema).optional(),
 });
 // ── Root state schema ───────────────────────────────────────────────

package/dist/core/search-budget.js

@@ -11,9 +11,9 @@
  * - Call waitForBudget() before making a Search API call to pace requests
  * - Call canAfford(n) to check if n more calls fit in the remaining budget
  */
-import { debug } from './logger.js';
-import { sleep } from './utils.js';
-const MODULE = 'search-budget';
+import { debug } from "./logger.js";
+import { sleep } from "./utils.js";
+const MODULE = "search-budget";
 /** GitHub Search API rate limit: 30 requests per 60-second rolling window. */
 const SEARCH_RATE_LIMIT = 30;
 const SEARCH_WINDOW_MS = 60 * 1000;

package/dist/core/search-phases.d.ts

@@ -4,10 +4,10 @@
  * Extracted from issue-discovery.ts to isolate search helpers,
  * caching, spam-filtering, and batched repo search logic.
  */
-import { Octokit } from '@octokit/rest';
-import { type SearchPriority, type IssueCandidate, type IssueScope } from './types.js';
-import { type GitHubSearchItem } from './issue-filtering.js';
-import { IssueVetter } from './issue-vetting.js';
+import { Octokit } from "@octokit/rest";
+import { type SearchPriority, type IssueCandidate, type IssueScope } from "./types.js";
+import { type GitHubSearchItem } from "./issue-filtering.js";
+import { IssueVetter } from "./issue-vetting.js";
 /** Resolve scope tiers into a flat label list, merged with custom labels. */
 export declare function buildEffectiveLabels(scopes: IssueScope[], customLabels: string[]): string[];
 /** Round-robin interleave multiple arrays. */
@@ -19,8 +19,8 @@ export declare function interleaveArrays<T>(arrays: T[][]): T[];
  */
 export declare function cachedSearchIssues(octokit: Octokit, params: {
     q: string;
-    sort: 'created' | 'updated' | 'comments' | 'reactions' | 'interactions';
-    order: 'asc' | 'desc';
+    sort: "created" | "updated" | "comments" | "reactions" | "interactions";
+    order: "asc" | "desc";
     per_page: number;
 }): Promise<{
     total_count: number;

package/dist/core/search-phases.js

@@ -4,14 +4,14 @@
  * Extracted from issue-discovery.ts to isolate search helpers,
  * caching, spam-filtering, and batched repo search logic.
  */
-import { SCOPE_LABELS } from './types.js';
-import { errorMessage, isRateLimitError } from './errors.js';
-import { debug, warn } from './logger.js';
-import { getHttpCache, cachedTimeBased } from './http-cache.js';
-import { detectLabelFarmingRepos } from './issue-filtering.js';
-import { sleep } from './utils.js';
-import { getSearchBudgetTracker } from './search-budget.js';
-const MODULE = 'search-phases';
+import { SCOPE_LABELS, } from "./types.js";
+import { errorMessage, isRateLimitError } from "./errors.js";
+import { debug, warn } from "./logger.js";
+import { getHttpCache, cachedTimeBased } from "./http-cache.js";
+import { detectLabelFarmingRepos, } from "./issue-filtering.js";
+import { extractRepoFromUrl, sleep } from "./utils.js";
+import { getSearchBudgetTracker } from "./search-budget.js";
+const MODULE = "search-phases";
 /** GitHub Search API enforces a max of 5 AND/OR/NOT operators per query. */
 const GITHUB_MAX_BOOLEAN_OPS = 5;
 /** Delay between search API calls to avoid GitHub's secondary rate limit (~30 req/min).
@@ -49,10 +49,10 @@ function chunkLabels(labels, reservedOps = 0) {
 /** Build a GitHub Search API label filter from a list of labels. */
 function buildLabelQuery(labels) {
     if (labels.length === 0)
-        return '';
+        return "";
     if (labels.length === 1)
         return `label:"${labels[0]}"`;
-    return `(${labels.map((l) => `label:"${l}"`).join(' OR ')})`;
+    return `(${labels.map((l) => `label:"${l}"`).join(" OR ")})`;
 }
 /** Resolve scope tiers into a flat label list, merged with custom labels. */
 export function buildEffectiveLabels(scopes, customLabels) {
@@ -132,8 +132,8 @@ export async function searchWithChunkedLabels(octokit, labels, reservedOps, buil
         const query = buildQuery(buildLabelQuery(labelChunks[i]));
         const data = await cachedSearchIssues(octokit, {
             q: query,
-            sort: 'created',
-            order: 'desc',
+            sort: "created",
+            order: "desc",
             per_page: perPage,
         });
         for (const item of data.items) {
@@ -152,12 +152,14 @@ export async function searchWithChunkedLabels(octokit, labels, reservedOps, buil
 export async function filterVetAndScore(vetter, items, filterIssues, excludedRepoSets, remainingNeeded, minStars, phaseLabel) {
     const spamRepos = detectLabelFarmingRepos(items);
     if (spamRepos.size > 0) {
-        const spamCount = items.filter((i) => spamRepos.has(i.repository_url.split('/').slice(-2).join('/'))).length;
-        debug(MODULE, `[SPAM_FILTER] Filtered ${spamCount} issues from ${spamRepos.size} label-farming repos: ${[...spamRepos].join(', ')}`);
+        const spamCount = items.filter((i) => spamRepos.has(extractRepoFromUrl(i.repository_url) ?? "")).length;
+        debug(MODULE, `[SPAM_FILTER] Filtered ${spamCount} issues from ${spamRepos.size} label-farming repos: ${[...spamRepos].join(", ")}`);
     }
     const itemsToVet = filterIssues(items)
         .filter((item) => {
-        const repoFullName = item.repository_url.split('/').slice(-2).join('/');
+        const repoFullName = extractRepoFromUrl(item.repository_url);
+        if (!repoFullName)
+            return false;
         if (spamRepos.has(repoFullName))
             return false;
         return excludedRepoSets.every((s) => !s.has(repoFullName));
@@ -167,7 +169,7 @@ export async function filterVetAndScore(vetter, items, filterIssues, excludedRep
         debug(MODULE, `[${phaseLabel}] All ${items.length} items filtered before vetting`);
         return { candidates: [], allVetFailed: false, rateLimitHit: false };
     }
-    const { candidates: results, allFailed: allVetFailed, rateLimitHit, } = await vetter.vetIssuesParallel(itemsToVet.map((i) => i.html_url), remainingNeeded, 'normal');
+    const { candidates: results, allFailed: allVetFailed, rateLimitHit, } = await vetter.vetIssuesParallel(itemsToVet.map((i) => i.html_url), remainingNeeded, "normal");
     const starFiltered = results.filter((c) => {
         if (c.projectHealth.checkFailed)
             return true;
@@ -206,10 +208,12 @@ export async function searchInRepos(octokit, vetter, repos, baseQualifiers, labe
         if (batchIdx > 0)
             await sleep(INTER_QUERY_DELAY_MS);
         try {
-            const repoFilter = batch.map((r) => `repo:${r}`).join(' OR ');
+            const repoFilter = batch.map((r) => `repo:${r}`).join(" OR ");
             const repoOps = batch.length - 1;
             const perPage = Math.min(30, (maxResults - candidates.length) * 3);
-            const allItems = await searchWithChunkedLabels(octokit, labels, repoOps, (labelQ) => `${baseQualifiers} ${labelQ} (${repoFilter})`.replace(/  +/g, ' ').trim(), perPage);
+            const allItems = await searchWithChunkedLabels(octokit, labels, repoOps, (labelQ) => `${baseQualifiers} ${labelQ} (${repoFilter})`
+                .replace(/  +/g, " ")
+                .trim(), perPage);
             if (allItems.length > 0) {
                 const filtered = filterFn(allItems);
                 const remainingNeeded = maxResults - candidates.length;
@@ -224,7 +228,7 @@ export async function searchInRepos(octokit, vetter, repos, baseQualifiers, labe
             if (isRateLimitError(error)) {
                 rateLimitFailures++;
             }
-            const batchReposStr = batch.join(', ');
+            const batchReposStr = batch.join(", ");
             warn(MODULE, `Error searching issues in batch [${batchReposStr}]:`, errorMessage(error));
         }
     }

package/dist/core/types.d.ts

@@ -1,8 +1,8 @@
 /**
  * Core types for oss-scout — ephemeral types that are never persisted.
  */
-import type { RepoSignals, TrackedIssue, IssueVettingResult, IssueScope, ScoutState, SearchStrategy } from './schemas.js';
-export type { ProjectCategory, IssueScope, RepoSignals, RepoScore, StoredMergedPR, StoredClosedPR, ContributionGuidelines, IssueVettingResult, TrackedIssue, ScoutPreferences, SavedCandidate, ScoutState, SearchStrategy, } from './schemas.js';
+import type { RepoSignals, TrackedIssue, IssueVettingResult, IssueScope, ScoutState, SearchStrategy } from "./schemas.js";
+export type { ProjectCategory, IssueScope, RepoSignals, RepoScore, StoredMergedPR, StoredClosedPR, ContributionGuidelines, IssueVettingResult, TrackedIssue, ScoutPreferences, SavedCandidate, ScoutState, SearchStrategy, } from "./schemas.js";
 /** Health snapshot of a GitHub repository. */
 export interface ProjectHealth {
     repo: string;
@@ -10,7 +10,7 @@ export interface ProjectHealth {
     daysSinceLastCommit: number;
     openIssuesCount: number;
     avgIssueResponseDays: number;
-    ciStatus: 'passing' | 'failing' | 'unknown';
+    ciStatus: "passing" | "failing" | "unknown";
     isActive: boolean;
     stargazersCount?: number;
     forksCount?: number;
@@ -19,13 +19,13 @@ export interface ProjectHealth {
     failureReason?: string;
 }
 /** Priority tier for issue search results. */
-export type SearchPriority = 'merged_pr' | 'preferred_org' | 'starred' | 'normal';
+export type SearchPriority = "merged_pr" | "preferred_org" | "starred" | "normal";
 /** A fully vetted issue candidate with scoring. */
 export interface IssueCandidate {
     issue: TrackedIssue;
     vettingResult: IssueVettingResult;
     projectHealth: ProjectHealth;
-    recommendation: 'approve' | 'skip' | 'needs_review';
+    recommendation: "approve" | "skip" | "needs_review";
     reasonsToSkip: string[];
     reasonsToApprove: string[];
     viabilityScore: number;
@@ -59,8 +59,8 @@ export interface VetListEntry {
     repo: string;
     number: number;
     title: string;
-    status: 'still_available' | 'claimed' | 'closed' | 'has_pr' | 'error';
-    recommendation?: 'approve' | 'skip' | 'needs_review';
+    status: "still_available" | "claimed" | "closed" | "has_pr" | "error";
+    recommendation?: "approve" | "skip" | "needs_review";
     viabilityScore?: number;
     errorMessage?: string;
 }
@@ -84,14 +84,14 @@ export type ScoutConfig = {
     /** GitHub token with `repo` read scope. Add `gist` scope for persistence. */
     githubToken: string;
     /** Use gist-backed persistence (default for standalone CLI). */
-    persistence?: 'gist';
+    persistence?: "gist";
     /** Gist ID override. Skips gist discovery/creation if provided. */
     gistId?: string;
 } | {
     /** GitHub token with `repo` read scope. */
     githubToken: string;
     /** Caller provides state directly. */
-    persistence: 'provided';
+    persistence: "provided";
     /** Pre-loaded state. Required when persistence is 'provided'. */
     initialState: ScoutState;
 };

package/dist/core/types.js

@@ -3,7 +3,19 @@
  */
 // ── Const arrays and mappings ───────────────────────────────────────
 export const SCOPE_LABELS = {
-    beginner: ['good first issue', 'help wanted', 'easy', 'up-for-grabs', 'first-timers-only', 'beginner'],
-    intermediate: ['enhancement', 'feature', 'feature-request', 'contributions welcome'],
-    advanced: ['proposal', 'RFC', 'accepted', 'design'],
+    beginner: [
+        "good first issue",
+        "help wanted",
+        "easy",
+        "up-for-grabs",
+        "first-timers-only",
+        "beginner",
+    ],
+    intermediate: [
+        "enhancement",
+        "feature",
+        "feature-request",
+        "contributions welcome",
+    ],
+    advanced: ["proposal", "RFC", "accepted", "design"],
 };

package/dist/core/utils.d.ts

@@ -4,11 +4,20 @@
 export declare function sleep(ms: number): Promise<void>;
 export declare function getDataDir(): string;
 export declare function getCacheDir(): string;
+/**
+ * Extract "owner/repo" from any GitHub URL format:
+ * - https://github.com/owner/repo
+ * - https://github.com/owner/repo/pull/123
+ * - https://github.com/owner/repo/issues/123
+ * - https://api.github.com/repos/owner/repo
+ * - https://api.github.com/repos/owner/repo/...
+ */
+export declare function extractRepoFromUrl(url: string): string | null;
 interface ParsedGitHubUrl {
     owner: string;
     repo: string;
     number: number;
-    type: 'pull' | 'issues';
+    type: "pull" | "issues";
 }
 export declare function parseGitHubUrl(url: string): ParsedGitHubUrl | null;
 export declare function daysBetween(from: Date, to?: Date): number;

package/dist/core/utils.js

@@ -1,39 +1,58 @@
 /**
  * Shared utility functions for oss-scout.
  */
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import { execFileSync } from 'child_process';
-import { ConfigurationError, errorMessage } from './errors.js';
-import { debug } from './logger.js';
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { execFileSync } from "child_process";
+import { ConfigurationError, errorMessage } from "./errors.js";
+import { debug } from "./logger.js";
 export function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-const MODULE = 'utils';
+const MODULE = "utils";
 let cachedGitHubToken = null;
 let tokenFetchAttempted = false;
 export function getDataDir() {
-    const dir = path.join(os.homedir(), '.oss-scout');
+    const dir = path.join(os.homedir(), ".oss-scout");
     if (!fs.existsSync(dir)) {
         fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
     }
     return dir;
 }
 export function getCacheDir() {
-    const dir = path.join(getDataDir(), 'cache');
+    const dir = path.join(getDataDir(), "cache");
     if (!fs.existsSync(dir)) {
         fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
     }
     return dir;
 }
+/**
+ * Extract "owner/repo" from any GitHub URL format:
+ * - https://github.com/owner/repo
+ * - https://github.com/owner/repo/pull/123
+ * - https://github.com/owner/repo/issues/123
+ * - https://api.github.com/repos/owner/repo
+ * - https://api.github.com/repos/owner/repo/...
+ */
+export function extractRepoFromUrl(url) {
+    // API URLs: https://api.github.com/repos/owner/repo[/...]
+    const apiMatch = url.match(/api\.github\.com\/repos\/([^/]+\/[^/]+)/);
+    if (apiMatch)
+        return apiMatch[1];
+    // Web URLs: https://github.com/owner/repo[/...]
+    const webMatch = url.match(/github\.com\/([^/]+\/[^/]+)/);
+    if (webMatch)
+        return webMatch[1];
+    return null;
+}
 const OWNER_PATTERN = /^[a-zA-Z0-9_-]+$/;
 const REPO_PATTERN = /^[a-zA-Z0-9_.-]+$/;
 function isValidOwnerRepo(owner, repo) {
     return OWNER_PATTERN.test(owner) && REPO_PATTERN.test(repo);
 }
 export function parseGitHubUrl(url) {
-    if (!url.startsWith('https://github.com/'))
+    if (!url.startsWith("https://github.com/"))
         return null;
     const prMatch = url.match(/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)/);
     if (prMatch) {
@@ -41,7 +60,7 @@ export function parseGitHubUrl(url) {
         const repo = prMatch[2];
         if (!isValidOwnerRepo(owner, repo))
             return null;
-        return { owner, repo, number: parseInt(prMatch[3], 10), type: 'pull' };
+        return { owner, repo, number: parseInt(prMatch[3], 10), type: "pull" };
     }
     const issueMatch = url.match(/github\.com\/([^/]+)\/([^/]+)\/issues\/(\d+)/);
     if (issueMatch) {
@@ -49,7 +68,7 @@ export function parseGitHubUrl(url) {
         const repo = issueMatch[2];
         if (!isValidOwnerRepo(owner, repo))
             return null;
-        return { owner, repo, number: parseInt(issueMatch[3], 10), type: 'issues' };
+        return { owner, repo, number: parseInt(issueMatch[3], 10), type: "issues" };
     }
     return null;
 }
@@ -58,12 +77,12 @@ export function daysBetween(from, to = new Date()) {
 }
 export function getCLIVersion() {
     try {
-        const pkgPath = path.join(path.dirname(process.argv[1]), '..', 'package.json');
-        return JSON.parse(fs.readFileSync(pkgPath, 'utf-8')).version;
+        const pkgPath = path.join(path.dirname(process.argv[1]), "..", "package.json");
+        return JSON.parse(fs.readFileSync(pkgPath, "utf-8")).version;
     }
     catch (err) {
         debug(MODULE, `Could not read CLI version: ${errorMessage(err)}`);
-        return 'unknown';
+        return "unknown";
     }
 }
 export function getGitHubToken() {
@@ -77,30 +96,30 @@ export function getGitHubToken() {
         return cachedGitHubToken;
     }
     try {
-        const token = execFileSync('gh', ['auth', 'token'], {
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
+        const token = execFileSync("gh", ["auth", "token"], {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
             timeout: 2000,
         }).trim();
         if (token && token.length > 0) {
             cachedGitHubToken = token;
-            debug(MODULE, 'Using GitHub token from gh CLI');
+            debug(MODULE, "Using GitHub token from gh CLI");
             return cachedGitHubToken;
         }
     }
     catch (err) {
-        debug(MODULE, 'gh auth token failed', err);
+        debug(MODULE, "gh auth token failed", err);
     }
     return null;
 }
 export function requireGitHubToken() {
     const token = getGitHubToken();
     if (!token) {
-        throw new ConfigurationError('GitHub authentication required.\n\n' +
-            'Options:\n' +
-            '  1. Use gh CLI: gh auth login\n' +
-            '  2. Set GITHUB_TOKEN environment variable\n\n' +
-            'The gh CLI is recommended - install from https://cli.github.com');
+        throw new ConfigurationError("GitHub authentication required.\n\n" +
+            "Options:\n" +
+            "  1. Use gh CLI: gh auth login\n" +
+            "  2. Set GITHUB_TOKEN environment variable\n\n" +
+            "The gh CLI is recommended - install from https://cli.github.com");
     }
     return token;
 }