@oss-scout/core 0.1.0

package/dist/core/logger.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Lightweight debug logger for oss-scout.
+ * Activated by the global --debug CLI flag.
+ *
+ * All debug/warn output goes to stderr so it never contaminates
+ * the --json stdout contract.
+ */
+export declare function enableDebug(): void;
+export declare function debug(module: string, message: string, ...args: unknown[]): void;
+export declare function info(module: string, message: string, ...args: unknown[]): void;
+export declare function warn(module: string, message: string, ...args: unknown[]): void;

package/dist/core/logger.js

@@ -0,0 +1,25 @@
+/**
+ * Lightweight debug logger for oss-scout.
+ * Activated by the global --debug CLI flag.
+ *
+ * All debug/warn output goes to stderr so it never contaminates
+ * the --json stdout contract.
+ */
+let debugEnabled = false;
+export function enableDebug() {
+    debugEnabled = true;
+}
+export function debug(module, message, ...args) {
+    if (!debugEnabled)
+        return;
+    const timestamp = new Date().toISOString();
+    console.error(`[${timestamp}] [DEBUG] [${module}] ${message}`, ...args);
+}
+export function info(module, message, ...args) {
+    const timestamp = new Date().toISOString();
+    console.error(`[${timestamp}] [INFO] [${module}] ${message}`, ...args);
+}
+export function warn(module, message, ...args) {
+    const timestamp = new Date().toISOString();
+    console.error(`[${timestamp}] [WARN] [${module}] ${message}`, ...args);
+}

package/dist/core/pagination.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Auto-paginate an Octokit list endpoint. Fetches additional pages when
+ * the result count equals per_page (indicating more data may exist).
+ */
+export declare function paginateAll<T>(fetchPage: (page: number) => Promise<{
+    data: T[];
+}>, perPage?: number, maxPages?: number): Promise<T[]>;

package/dist/core/pagination.js

@@ -0,0 +1,16 @@
+/** Maximum pages to fetch to prevent runaway pagination */
+const MAX_PAGES = 10;
+/**
+ * Auto-paginate an Octokit list endpoint. Fetches additional pages when
+ * the result count equals per_page (indicating more data may exist).
+ */
+export async function paginateAll(fetchPage, perPage = 100, maxPages = MAX_PAGES) {
+    const allItems = [];
+    for (let page = 1; page <= maxPages; page++) {
+        const { data } = await fetchPage(page);
+        allItems.push(...data);
+        if (data.length < perPage)
+            break;
+    }
+    return allItems;
+}

package/dist/core/repo-health.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Repo Health — project health checks and contribution guidelines fetching.
+ *
+ * Extracted from issue-vetting.ts to isolate repo-level checks
+ * from issue-level eligibility logic.
+ */
+import { Octokit } from '@octokit/rest';
+import { type ContributionGuidelines, type ProjectHealth } from './types.js';
+/**
+ * Check the health of a GitHub project: recent commits, CI status, star/fork counts.
+ * Results are cached for HEALTH_CACHE_TTL_MS (4 hours).
+ */
+export declare function checkProjectHealth(octokit: Octokit, owner: string, repo: string): Promise<ProjectHealth>;
+/**
+ * Fetch and parse CONTRIBUTING.md (or variants) from a GitHub repo.
+ * Probes multiple paths in parallel: CONTRIBUTING.md, .github/CONTRIBUTING.md,
+ * docs/CONTRIBUTING.md, contributing.md. Results are cached for CACHE_TTL_MS.
+ */
+export declare function fetchContributionGuidelines(octokit: Octokit, owner: string, repo: string): Promise<ContributionGuidelines | undefined>;

package/dist/core/repo-health.js

@@ -0,0 +1,179 @@
+/**
+ * Repo Health — project health checks and contribution guidelines fetching.
+ *
+ * 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';
+// ── Cache for contribution guidelines ──
+const guidelinesCache = new Map();
+/** TTL for cached contribution guidelines (1 hour). */
+const CACHE_TTL_MS = 60 * 60 * 1000;
+/** TTL for cached project health results (4 hours). Health data (stars, commits, CI) changes slowly. */
+const HEALTH_CACHE_TTL_MS = 4 * 60 * 60 * 1000;
+/** Max entries in the guidelines cache before pruning. */
+const CACHE_MAX_SIZE = 100;
+/** Remove expired and excess entries from the guidelines cache. */
+function pruneCache() {
+    const now = Date.now();
+    // First, remove expired entries (older than CACHE_TTL_MS)
+    for (const [key, value] of guidelinesCache.entries()) {
+        if (now - value.fetchedAt > CACHE_TTL_MS) {
+            guidelinesCache.delete(key);
+        }
+    }
+    // Then, if still over size limit, remove oldest entries
+    if (guidelinesCache.size > CACHE_MAX_SIZE) {
+        const entries = Array.from(guidelinesCache.entries()).sort((a, b) => a[1].fetchedAt - b[1].fetchedAt);
+        const toRemove = entries.slice(0, guidelinesCache.size - CACHE_MAX_SIZE);
+        for (const [key] of toRemove) {
+            guidelinesCache.delete(key);
+        }
+    }
+}
+// ── Project health ──
+/**
+ * Check the health of a GitHub project: recent commits, CI status, star/fork counts.
+ * Results are cached for HEALTH_CACHE_TTL_MS (4 hours).
+ */
+export async function checkProjectHealth(octokit, owner, repo) {
+    const cache = getHttpCache();
+    const healthCacheKey = `health:${owner}/${repo}`;
+    try {
+        return await cachedTimeBased(cache, healthCacheKey, HEALTH_CACHE_TTL_MS, async () => {
+            // Get repo info (with ETag caching — repo metadata changes infrequently)
+            const url = `/repos/${owner}/${repo}`;
+            const repoData = await cachedRequest(cache, url, (headers) => octokit.repos.get({ owner, repo, headers }));
+            // Get recent commits
+            const { data: commits } = await octokit.repos.listCommits({
+                owner,
+                repo,
+                per_page: 1,
+            });
+            const lastCommit = commits[0];
+            const lastCommitAt = lastCommit?.commit?.author?.date || repoData.pushed_at;
+            const daysSinceLastCommit = daysBetween(new Date(lastCommitAt));
+            const ciStatus = 'unknown';
+            return {
+                repo: `${owner}/${repo}`,
+                lastCommitAt,
+                daysSinceLastCommit,
+                openIssuesCount: repoData.open_issues_count,
+                avgIssueResponseDays: 0, // Would need more API calls to calculate
+                ciStatus,
+                isActive: daysSinceLastCommit < 30,
+                stargazersCount: repoData.stargazers_count,
+                forksCount: repoData.forks_count,
+                language: repoData.language,
+            };
+        });
+    }
+    catch (error) {
+        const errMsg = errorMessage(error);
+        warn(MODULE, `Error checking project health for ${owner}/${repo}: ${errMsg}`);
+        return {
+            repo: `${owner}/${repo}`,
+            lastCommitAt: '',
+            daysSinceLastCommit: 999,
+            openIssuesCount: 0,
+            avgIssueResponseDays: 0,
+            ciStatus: 'unknown',
+            isActive: false,
+            checkFailed: true,
+            failureReason: errMsg,
+        };
+    }
+}
+// ── Contribution guidelines ──
+/**
+ * Fetch and parse CONTRIBUTING.md (or variants) from a GitHub repo.
+ * Probes multiple paths in parallel: CONTRIBUTING.md, .github/CONTRIBUTING.md,
+ * docs/CONTRIBUTING.md, contributing.md. Results are cached for CACHE_TTL_MS.
+ */
+export async function fetchContributionGuidelines(octokit, owner, repo) {
+    const cacheKey = `${owner}/${repo}`;
+    // Check cache first
+    const cached = guidelinesCache.get(cacheKey);
+    if (cached && Date.now() - cached.fetchedAt < CACHE_TTL_MS) {
+        return cached.guidelines;
+    }
+    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');
+        }
+        return null;
+    })));
+    for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        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')) {
+                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() });
+    pruneCache();
+    return undefined;
+}
+/**
+ * Parse the raw content of a CONTRIBUTING.md file to extract structured guidelines:
+ * branch naming, commit format, test framework, linter, formatter, CLA requirement.
+ */
+function parseContributionGuidelines(content) {
+    const guidelines = {
+        rawContent: content,
+    };
+    const lowerContent = content.toLowerCase();
+    // Detect branch naming conventions
+    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';
+    }
+    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';
+    // 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';
+    // Detect CLA requirement
+    if (lowerContent.includes('cla') || lowerContent.includes('contributor license agreement')) {
+        guidelines.claRequired = true;
+    }
+    return guidelines;
+}

package/dist/core/schemas.d.ts

@@ -0,0 +1,315 @@
+/**
+ * Zod schemas for all types persisted in oss-scout state.
+ *
+ * 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';
+export declare const IssueStatusSchema: z.ZodEnum<{
+    candidate: "candidate";
+    claimed: "claimed";
+    in_progress: "in_progress";
+    pr_submitted: "pr_submitted";
+}>;
+export declare const ProjectCategorySchema: z.ZodEnum<{
+    nonprofit: "nonprofit";
+    devtools: "devtools";
+    infrastructure: "infrastructure";
+    "web-frameworks": "web-frameworks";
+    "data-ml": "data-ml";
+    education: "education";
+}>;
+export declare const IssueScopeSchema: z.ZodEnum<{
+    advanced: "advanced";
+    beginner: "beginner";
+    intermediate: "intermediate";
+}>;
+export declare const SearchStrategySchema: z.ZodEnum<{
+    all: "all";
+    merged: "merged";
+    orgs: "orgs";
+    starred: "starred";
+    broad: "broad";
+    maintained: "maintained";
+}>;
+/** All concrete strategies (excludes 'all' meta-strategy). */
+export declare const CONCRETE_STRATEGIES: readonly ["merged", "orgs", "starred", "broad", "maintained"];
+export declare const RepoSignalsSchema: z.ZodObject<{
+    hasActiveMaintainers: z.ZodBoolean;
+    isResponsive: z.ZodBoolean;
+    hasHostileComments: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const RepoScoreSchema: z.ZodObject<{
+    repo: z.ZodString;
+    score: z.ZodNumber;
+    mergedPRCount: z.ZodNumber;
+    closedWithoutMergeCount: z.ZodNumber;
+    avgResponseDays: z.ZodNullable<z.ZodNumber>;
+    lastMergedAt: z.ZodOptional<z.ZodString>;
+    lastEvaluatedAt: z.ZodString;
+    signals: z.ZodObject<{
+        hasActiveMaintainers: z.ZodBoolean;
+        isResponsive: z.ZodBoolean;
+        hasHostileComments: z.ZodBoolean;
+    }, z.core.$strip>;
+    stargazersCount: z.ZodOptional<z.ZodNumber>;
+    language: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export declare const StoredMergedPRSchema: z.ZodObject<{
+    url: z.ZodString;
+    title: z.ZodString;
+    mergedAt: z.ZodString;
+}, z.core.$strip>;
+export declare const StoredClosedPRSchema: z.ZodObject<{
+    url: z.ZodString;
+    title: z.ZodString;
+    closedAt: z.ZodString;
+}, z.core.$strip>;
+export declare const ContributionGuidelinesSchema: z.ZodObject<{
+    branchNamingConvention: z.ZodOptional<z.ZodString>;
+    commitMessageFormat: z.ZodOptional<z.ZodString>;
+    prTitleFormat: z.ZodOptional<z.ZodString>;
+    requiredChecks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    testFramework: z.ZodOptional<z.ZodString>;
+    testCoverageRequired: z.ZodOptional<z.ZodBoolean>;
+    testFileNaming: z.ZodOptional<z.ZodString>;
+    linter: z.ZodOptional<z.ZodString>;
+    formatter: z.ZodOptional<z.ZodString>;
+    styleGuideUrl: z.ZodOptional<z.ZodString>;
+    issueClaimProcess: z.ZodOptional<z.ZodString>;
+    reviewProcess: z.ZodOptional<z.ZodString>;
+    claRequired: z.ZodOptional<z.ZodBoolean>;
+    rawContent: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const IssueVettingResultSchema: z.ZodObject<{
+    passedAllChecks: z.ZodBoolean;
+    checks: z.ZodObject<{
+        noExistingPR: z.ZodBoolean;
+        notClaimed: z.ZodBoolean;
+        projectActive: z.ZodBoolean;
+        clearRequirements: z.ZodBoolean;
+        contributionGuidelinesFound: z.ZodBoolean;
+    }, z.core.$strip>;
+    contributionGuidelines: z.ZodOptional<z.ZodObject<{
+        branchNamingConvention: z.ZodOptional<z.ZodString>;
+        commitMessageFormat: z.ZodOptional<z.ZodString>;
+        prTitleFormat: z.ZodOptional<z.ZodString>;
+        requiredChecks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        testFramework: z.ZodOptional<z.ZodString>;
+        testCoverageRequired: z.ZodOptional<z.ZodBoolean>;
+        testFileNaming: z.ZodOptional<z.ZodString>;
+        linter: z.ZodOptional<z.ZodString>;
+        formatter: z.ZodOptional<z.ZodString>;
+        styleGuideUrl: z.ZodOptional<z.ZodString>;
+        issueClaimProcess: z.ZodOptional<z.ZodString>;
+        reviewProcess: z.ZodOptional<z.ZodString>;
+        claRequired: z.ZodOptional<z.ZodBoolean>;
+        rawContent: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    notes: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const TrackedIssueSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    url: z.ZodString;
+    repo: z.ZodString;
+    number: z.ZodNumber;
+    title: z.ZodString;
+    status: z.ZodEnum<{
+        candidate: "candidate";
+        claimed: "claimed";
+        in_progress: "in_progress";
+        pr_submitted: "pr_submitted";
+    }>;
+    labels: z.ZodArray<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    vetted: z.ZodBoolean;
+    vettingResult: z.ZodOptional<z.ZodObject<{
+        passedAllChecks: z.ZodBoolean;
+        checks: z.ZodObject<{
+            noExistingPR: z.ZodBoolean;
+            notClaimed: z.ZodBoolean;
+            projectActive: z.ZodBoolean;
+            clearRequirements: z.ZodBoolean;
+            contributionGuidelinesFound: z.ZodBoolean;
+        }, z.core.$strip>;
+        contributionGuidelines: z.ZodOptional<z.ZodObject<{
+            branchNamingConvention: z.ZodOptional<z.ZodString>;
+            commitMessageFormat: z.ZodOptional<z.ZodString>;
+            prTitleFormat: z.ZodOptional<z.ZodString>;
+            requiredChecks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            testFramework: z.ZodOptional<z.ZodString>;
+            testCoverageRequired: z.ZodOptional<z.ZodBoolean>;
+            testFileNaming: z.ZodOptional<z.ZodString>;
+            linter: z.ZodOptional<z.ZodString>;
+            formatter: z.ZodOptional<z.ZodString>;
+            styleGuideUrl: z.ZodOptional<z.ZodString>;
+            issueClaimProcess: z.ZodOptional<z.ZodString>;
+            reviewProcess: z.ZodOptional<z.ZodString>;
+            claRequired: z.ZodOptional<z.ZodBoolean>;
+            rawContent: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        notes: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const SavedCandidateSchema: z.ZodObject<{
+    issueUrl: z.ZodString;
+    repo: z.ZodString;
+    number: z.ZodNumber;
+    title: z.ZodString;
+    labels: z.ZodArray<z.ZodString>;
+    recommendation: z.ZodEnum<{
+        approve: "approve";
+        skip: "skip";
+        needs_review: "needs_review";
+    }>;
+    viabilityScore: z.ZodNumber;
+    searchPriority: z.ZodString;
+    firstSeenAt: z.ZodString;
+    lastSeenAt: z.ZodString;
+    lastScore: z.ZodNumber;
+}, z.core.$strip>;
+export declare const PersistenceModeSchema: z.ZodEnum<{
+    local: "local";
+    gist: "gist";
+}>;
+export declare const ScoutPreferencesSchema: z.ZodObject<{
+    githubUsername: z.ZodDefault<z.ZodString>;
+    languages: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    scope: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        advanced: "advanced";
+        beginner: "beginner";
+        intermediate: "intermediate";
+    }>>>;
+    excludeRepos: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    aiPolicyBlocklist: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    preferredOrgs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    projectCategories: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        nonprofit: "nonprofit";
+        devtools: "devtools";
+        infrastructure: "infrastructure";
+        "web-frameworks": "web-frameworks";
+        "data-ml": "data-ml";
+        education: "education";
+    }>>>;
+    minStars: z.ZodDefault<z.ZodNumber>;
+    maxIssueAgeDays: z.ZodDefault<z.ZodNumber>;
+    includeDocIssues: z.ZodDefault<z.ZodBoolean>;
+    minRepoScoreThreshold: z.ZodDefault<z.ZodNumber>;
+    persistence: z.ZodDefault<z.ZodEnum<{
+        local: "local";
+        gist: "gist";
+    }>>;
+    defaultStrategy: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        all: "all";
+        merged: "merged";
+        orgs: "orgs";
+        starred: "starred";
+        broad: "broad";
+        maintained: "maintained";
+    }>>>;
+}, z.core.$strip>;
+export declare const ScoutStateSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    preferences: z.ZodDefault<z.ZodObject<{
+        githubUsername: z.ZodDefault<z.ZodString>;
+        languages: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        scope: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            advanced: "advanced";
+            beginner: "beginner";
+            intermediate: "intermediate";
+        }>>>;
+        excludeRepos: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        aiPolicyBlocklist: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        preferredOrgs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        projectCategories: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            nonprofit: "nonprofit";
+            devtools: "devtools";
+            infrastructure: "infrastructure";
+            "web-frameworks": "web-frameworks";
+            "data-ml": "data-ml";
+            education: "education";
+        }>>>;
+        minStars: z.ZodDefault<z.ZodNumber>;
+        maxIssueAgeDays: z.ZodDefault<z.ZodNumber>;
+        includeDocIssues: z.ZodDefault<z.ZodBoolean>;
+        minRepoScoreThreshold: z.ZodDefault<z.ZodNumber>;
+        persistence: z.ZodDefault<z.ZodEnum<{
+            local: "local";
+            gist: "gist";
+        }>>;
+        defaultStrategy: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            all: "all";
+            merged: "merged";
+            orgs: "orgs";
+            starred: "starred";
+            broad: "broad";
+            maintained: "maintained";
+        }>>>;
+    }, z.core.$strip>>;
+    repoScores: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        repo: z.ZodString;
+        score: z.ZodNumber;
+        mergedPRCount: z.ZodNumber;
+        closedWithoutMergeCount: z.ZodNumber;
+        avgResponseDays: z.ZodNullable<z.ZodNumber>;
+        lastMergedAt: z.ZodOptional<z.ZodString>;
+        lastEvaluatedAt: z.ZodString;
+        signals: z.ZodObject<{
+            hasActiveMaintainers: z.ZodBoolean;
+            isResponsive: z.ZodBoolean;
+            hasHostileComments: z.ZodBoolean;
+        }, z.core.$strip>;
+        stargazersCount: z.ZodOptional<z.ZodNumber>;
+        language: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>>;
+    starredRepos: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    starredReposLastFetched: z.ZodOptional<z.ZodString>;
+    mergedPRs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        title: z.ZodString;
+        mergedAt: z.ZodString;
+    }, z.core.$strip>>>;
+    closedPRs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        title: z.ZodString;
+        closedAt: z.ZodString;
+    }, z.core.$strip>>>;
+    savedResults: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        issueUrl: z.ZodString;
+        repo: z.ZodString;
+        number: z.ZodNumber;
+        title: z.ZodString;
+        labels: z.ZodArray<z.ZodString>;
+        recommendation: z.ZodEnum<{
+            approve: "approve";
+            skip: "skip";
+            needs_review: "needs_review";
+        }>;
+        viabilityScore: z.ZodNumber;
+        searchPriority: z.ZodString;
+        firstSeenAt: z.ZodString;
+        lastSeenAt: z.ZodString;
+        lastScore: z.ZodNumber;
+    }, z.core.$strip>>>;
+    lastSearchAt: z.ZodOptional<z.ZodString>;
+    lastRunAt: z.ZodDefault<z.ZodString>;
+    gistId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type IssueStatus = z.infer<typeof IssueStatusSchema>;
+export type ProjectCategory = z.infer<typeof ProjectCategorySchema>;
+export type IssueScope = z.infer<typeof IssueScopeSchema>;
+export type SearchStrategy = z.infer<typeof SearchStrategySchema>;
+export type RepoSignals = z.infer<typeof RepoSignalsSchema>;
+export type RepoScore = z.infer<typeof RepoScoreSchema>;
+export type StoredMergedPR = z.infer<typeof StoredMergedPRSchema>;
+export type StoredClosedPR = z.infer<typeof StoredClosedPRSchema>;
+export type ContributionGuidelines = z.infer<typeof ContributionGuidelinesSchema>;
+export type IssueVettingResult = z.infer<typeof IssueVettingResultSchema>;
+export type TrackedIssue = z.infer<typeof TrackedIssueSchema>;
+export type PersistenceMode = z.infer<typeof PersistenceModeSchema>;
+export type ScoutPreferences = z.infer<typeof ScoutPreferencesSchema>;
+export type SavedCandidate = z.infer<typeof SavedCandidateSchema>;
+export type ScoutState = z.infer<typeof ScoutStateSchema>;