@oss-scout/core 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+/**
+ * oss-scout CLI — Find open source issues personalized to your contribution history.
+ */
+export {};

package/dist/cli.js

@@ -0,0 +1,341 @@
+#!/usr/bin/env node
+/**
+ * oss-scout CLI — Find open source issues personalized to your contribution history.
+ */
+import { Command } from 'commander';
+import { enableDebug } from './core/logger.js';
+import { getCLIVersion } from './core/utils.js';
+import { formatJsonSuccess, formatJsonError } from './formatters/json.js';
+import { errorMessage, resolveErrorCode } from './core/errors.js';
+import { hasLocalState, loadLocalState, saveLocalState } from './core/local-state.js';
+import { CONCRETE_STRATEGIES, SearchStrategySchema } from './core/schemas.js';
+function handleCommandError(err, options) {
+    if (options.json) {
+        console.log(formatJsonError(errorMessage(err), resolveErrorCode(err)));
+    }
+    else {
+        console.error('Error:', errorMessage(err));
+    }
+    process.exit(1);
+}
+const program = new Command();
+program
+    .name('oss-scout')
+    .description('Find open source issues personalized to your contribution history')
+    .version(getCLIVersion())
+    .option('--debug', 'Enable debug output');
+// Parse --debug early so it's available in preAction hooks
+program.hook('preAction', (_thisCommand, _actionCommand) => {
+    const opts = program.opts();
+    if (opts.debug)
+        enableDebug();
+});
+program
+    .command('setup')
+    .description('Interactive first-run configuration')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    try {
+        const { runSetup } = await import('./commands/setup.js');
+        const prefs = await runSetup();
+        const state = loadLocalState();
+        state.preferences = prefs;
+        saveLocalState(state);
+        if (options.json) {
+            console.log(formatJsonSuccess(prefs));
+        }
+    }
+    catch (err) {
+        handleCommandError(err, options);
+    }
+});
+program
+    .command('bootstrap')
+    .description('Import starred repos and PR history from GitHub')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    try {
+        const { bootstrapScout } = await import('./core/bootstrap.js');
+        const { createScout } = await import('./scout.js');
+        const { requireGitHubToken } = await import('./core/utils.js');
+        const token = requireGitHubToken();
+        const state = loadLocalState();
+        const scout = await createScout({ githubToken: token, persistence: 'provided', initialState: state });
+        const result = await bootstrapScout(scout, token);
+        saveLocalState(scout.getState());
+        if (options.json) {
+            console.log(formatJsonSuccess(result));
+        }
+        else {
+            if (result.skippedDueToRateLimit) {
+                console.log('Skipped: GitHub API rate limit too low. Try again later.');
+            }
+            else {
+                console.log(`Imported ${result.mergedPRCount} merged PRs, ${result.closedPRCount} closed PRs, ${result.starredRepoCount} starred repos`);
+                console.log(`Scored ${result.reposScoredCount} repositories`);
+            }
+        }
+    }
+    catch (err) {
+        handleCommandError(err, options);
+    }
+});
+program
+    .command('search [count]')
+    .description('Search for contributable issues using multi-strategy discovery')
+    .option('--json', 'Output as JSON')
+    .option('--strategy <strategies>', `Search strategies (${CONCRETE_STRATEGIES.join(',')},all)`, 'all')
+    .action(async (count, options) => {
+    try {
+        if (!hasLocalState()) {
+            console.log('💡 Run `oss-scout setup` to configure your preferences for personalized search results.\n');
+        }
+        const { runSearch } = await import('./commands/search.js');
+        const maxResults = count ? parseInt(count, 10) : 10;
+        if (isNaN(maxResults) || maxResults < 1) {
+            console.error('Error: count must be a positive integer');
+            process.exit(1);
+        }
+        const state = loadLocalState();
+        if (state.mergedPRs.length === 0 &&
+            state.starredRepos.length === 0 &&
+            state.preferences.githubUsername) {
+            console.log('Run `oss-scout bootstrap` to import your starred repos and PR history for better results.\n');
+        }
+        // Parse --strategy option
+        const strategyTokens = (options.strategy ?? 'all').split(',').map(s => s.trim()).filter(Boolean);
+        const strategies = [];
+        for (const token of strategyTokens) {
+            const parsed = SearchStrategySchema.safeParse(token);
+            if (!parsed.success) {
+                const valid = [...CONCRETE_STRATEGIES, 'all'].join(', ');
+                console.error('Error: unknown strategy "' + token + '". Valid strategies: ' + valid);
+                process.exit(1);
+            }
+            strategies.push(parsed.data);
+        }
+        const results = await runSearch({ maxResults, state, strategies });
+        if (options.json) {
+            console.log(formatJsonSuccess(results));
+        }
+        else {
+            // Human-readable output
+            console.log(`\nFound ${results.candidates.length} issue candidates:\n`);
+            for (const c of results.candidates) {
+                const icon = c.recommendation === 'approve' ? '✅' : c.recommendation === 'skip' ? '❌' : '⚠️';
+                console.log(`  ${icon} ${c.issue.repo}#${c.issue.number} [${c.viabilityScore}/100]`);
+                console.log(`     ${c.issue.title}`);
+                console.log(`     ${c.issue.url}`);
+                if (c.repoScore) {
+                    console.log(`     Repo: ${c.repoScore.score}/10, ${c.repoScore.mergedPRCount} merged PRs`);
+                }
+                console.log();
+            }
+            if (results.rateLimitWarning) {
+                console.error(`\n⚠️  ${results.rateLimitWarning}`);
+            }
+        }
+    }
+    catch (err) {
+        handleCommandError(err, options);
+    }
+});
+// ── results command ────────────────────────────────────────────────
+const resultsCmd = program
+    .command('results')
+    .description('Show saved search results');
+resultsCmd
+    .command('show', { isDefault: true })
+    .description('Display saved search results')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    try {
+        const { runResults } = await import('./commands/results.js');
+        const results = await runResults(options);
+        if (options.json) {
+            console.log(formatJsonSuccess(results));
+        }
+        else {
+            if (results.length === 0) {
+                console.log('\nNo saved results. Run `oss-scout search` to find issues.\n');
+                return;
+            }
+            console.log(`\nSaved results (${results.length}):\n`);
+            console.log('  Score  Repo                              Issue   Recommendation  Title');
+            console.log('  ─────  ────────────────────────────────  ──────  ──────────────  ─────');
+            for (const r of results) {
+                const score = String(r.viabilityScore).padStart(3);
+                const repo = r.repo.padEnd(32).slice(0, 32);
+                const issue = `#${r.number}`.padEnd(6);
+                const rec = r.recommendation.padEnd(14);
+                const title = r.title.length > 50 ? r.title.slice(0, 47) + '...' : r.title;
+                console.log(`  ${score}    ${repo}  ${issue}  ${rec}  ${title}`);
+            }
+            console.log();
+        }
+    }
+    catch (err) {
+        handleCommandError(err, options);
+    }
+});
+resultsCmd
+    .command('clear')
+    .description('Clear all saved results')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    try {
+        const { runResultsClear } = await import('./commands/results.js');
+        await runResultsClear();
+        if (options.json) {
+            console.log(formatJsonSuccess({ cleared: true }));
+        }
+        else {
+            console.log('Saved results cleared.');
+        }
+    }
+    catch (err) {
+        handleCommandError(err, options);
+    }
+});
+// ── config command ──────────────────────────────────────────────────
+const configCmd = program
+    .command('config')
+    .description('View and update preferences')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    try {
+        const { runConfigShow, getConfigData } = await import('./commands/config.js');
+        if (options.json) {
+            console.log(formatJsonSuccess(getConfigData()));
+        }
+        else {
+            runConfigShow(options);
+        }
+    }
+    catch (err) {
+        handleCommandError(err, options);
+    }
+});
+configCmd
+    .command('set <key> <value>')
+    .description('Update a single preference (e.g. config set minStars 100)')
+    .option('--json', 'Output as JSON')
+    .action(async (key, value, options) => {
+    try {
+        const { runConfigSet } = await import('./commands/config.js');
+        const updated = runConfigSet(key, value);
+        if (options.json) {
+            console.log(formatJsonSuccess(updated));
+        }
+        else {
+            console.log(`✅ Updated "${key}" successfully.`);
+        }
+    }
+    catch (err) {
+        handleCommandError(err, options);
+    }
+});
+configCmd
+    .command('reset')
+    .description('Reset all preferences to defaults')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    try {
+        const { runConfigReset } = await import('./commands/config.js');
+        const defaults = runConfigReset();
+        if (options.json) {
+            console.log(formatJsonSuccess(defaults));
+        }
+        else {
+            console.log('✅ Preferences reset to defaults.');
+        }
+    }
+    catch (err) {
+        handleCommandError(err, options);
+    }
+});
+program
+    .command('vet-list')
+    .description('Re-vet all saved search results and classify their current status')
+    .option('--prune', 'Remove unavailable issues from saved results')
+    .option('--concurrency <n>', 'Max concurrent API requests (default: 5)', parseInt)
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    try {
+        if (options.concurrency !== undefined && (isNaN(options.concurrency) || options.concurrency < 1)) {
+            console.error('Error: --concurrency must be a positive integer');
+            process.exit(1);
+        }
+        const { runVetList } = await import('./commands/vet-list.js');
+        const state = loadLocalState();
+        const result = await runVetList({
+            state,
+            prune: options.prune,
+            concurrency: options.concurrency,
+        });
+        if (options.json) {
+            console.log(formatJsonSuccess(result));
+        }
+        else {
+            if (result.results.length === 0) {
+                console.log('\nNo saved results to vet. Run `oss-scout search` first.\n');
+                return;
+            }
+            console.log(`\nVet-list results (${result.summary.total}):\n`);
+            for (const r of result.results) {
+                const icon = r.status === 'still_available' ? '✅' :
+                    r.status === 'claimed' ? '🔒' :
+                        r.status === 'has_pr' ? '🔀' :
+                            r.status === 'closed' ? '🚫' : '❌';
+                const score = r.viabilityScore != null ? ` [${r.viabilityScore}/100]` : '';
+                console.log(`  ${icon} ${r.repo}#${r.number} — ${r.status}${score}`);
+                console.log(`     ${r.title}`);
+            }
+            console.log(`\nSummary: ${result.summary.stillAvailable} available, ${result.summary.claimed} claimed, ${result.summary.hasPR} has PR, ${result.summary.closed} closed, ${result.summary.errors} errors`);
+            if (result.prunedCount != null) {
+                console.log(`Pruned ${result.prunedCount} unavailable issues from saved results.`);
+            }
+            console.log();
+        }
+    }
+    catch (err) {
+        handleCommandError(err, options);
+    }
+});
+program
+    .command('vet <issue-url>')
+    .description('Vet a specific GitHub issue for claimability and project health')
+    .option('--json', 'Output as JSON')
+    .action(async (issueUrl, options) => {
+    try {
+        const { runVet } = await import('./commands/vet.js');
+        const state = loadLocalState();
+        const result = await runVet({ issueUrl, state });
+        if (options.json) {
+            console.log(formatJsonSuccess(result));
+        }
+        else {
+            const icon = result.recommendation === 'approve' ? '✅' : result.recommendation === 'skip' ? '❌' : '⚠️';
+            console.log(`\n${icon} ${result.issue.repo}#${result.issue.number}: ${result.recommendation.toUpperCase()}`);
+            console.log(`   ${result.issue.title}`);
+            console.log(`   ${result.issue.url}\n`);
+            if (result.reasonsToApprove.length > 0) {
+                console.log('Reasons to approve:');
+                for (const r of result.reasonsToApprove)
+                    console.log(`  + ${r}`);
+            }
+            if (result.reasonsToSkip.length > 0) {
+                console.log('Reasons to skip:');
+                for (const r of result.reasonsToSkip)
+                    console.log(`  - ${r}`);
+            }
+            console.log(`\nProject health: ${result.projectHealth.isActive ? 'Active' : 'Inactive'}`);
+            console.log(`  Last commit: ${result.projectHealth.daysSinceLastCommit} days ago`);
+            console.log(`  CI status: ${result.projectHealth.ciStatus}`);
+        }
+    }
+    catch (err) {
+        handleCommandError(err, options);
+    }
+});
+program.parse();

package/dist/commands/config.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Config command — view and update oss-scout preferences.
+ */
+import type { ScoutPreferences } from '../core/schemas.js';
+/**
+ * Display current preferences in human-readable format.
+ */
+export declare function runConfigShow(options: {
+    json?: boolean;
+}): void;
+/**
+ * Get current preferences for JSON output.
+ */
+export declare function getConfigData(): ScoutPreferences;
+/**
+ * Update a single preference by key.
+ */
+export declare function runConfigSet(key: string, value: string): ScoutPreferences;
+/**
+ * Reset preferences to defaults.
+ */
+export declare function runConfigReset(): ScoutPreferences;

package/dist/commands/config.js

@@ -0,0 +1,169 @@
+/**
+ * Config command — view and update oss-scout preferences.
+ */
+import { loadLocalState, saveLocalState } from '../core/local-state.js';
+import { ScoutPreferencesSchema, IssueScopeSchema, ProjectCategorySchema, PersistenceModeSchema } from '../core/schemas.js';
+import { ValidationError } from '../core/errors.js';
+/** All known preference keys and their types. */
+const ARRAY_FIELDS = new Set([
+    'languages',
+    'labels',
+    'preferredOrgs',
+    'projectCategories',
+    'excludeRepos',
+    'aiPolicyBlocklist',
+]);
+const NUMBER_FIELDS = new Set(['minStars', 'maxIssueAgeDays', 'minRepoScoreThreshold']);
+const BOOLEAN_FIELDS = new Set(['includeDocIssues']);
+const STRING_FIELDS = new Set(['githubUsername']);
+const SCOPE_FIELD = 'scope';
+const ENUM_FIELDS = {
+    persistence: PersistenceModeSchema.options,
+};
+const ALL_FIELDS = new Set([
+    ...ARRAY_FIELDS,
+    ...NUMBER_FIELDS,
+    ...BOOLEAN_FIELDS,
+    ...STRING_FIELDS,
+    ...Object.keys(ENUM_FIELDS),
+    SCOPE_FIELD,
+]);
+const VALID_SCOPES = IssueScopeSchema.options;
+const VALID_CATEGORIES = ProjectCategorySchema.options;
+function parseBoolean(value) {
+    const lower = value.toLowerCase();
+    if (lower === 'true' || lower === 'yes')
+        return true;
+    if (lower === 'false' || lower === 'no')
+        return false;
+    throw new ValidationError(`Invalid boolean value: "${value}". Use true/false or yes/no.`);
+}
+function parseNumber(value, key) {
+    const num = parseInt(value, 10);
+    if (isNaN(num)) {
+        throw new ValidationError(`Invalid number for "${key}": "${value}"`);
+    }
+    return num;
+}
+function parseArrayValue(value) {
+    return value
+        .split(',')
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+}
+/**
+ * Apply an array update: plain set, +append, or -remove.
+ */
+function updateArray(current, value) {
+    if (value.startsWith('+')) {
+        const toAdd = parseArrayValue(value.slice(1));
+        const merged = [...current];
+        for (const item of toAdd) {
+            if (!merged.includes(item))
+                merged.push(item);
+        }
+        return merged;
+    }
+    if (value.startsWith('-')) {
+        const toRemove = new Set(parseArrayValue(value.slice(1)));
+        return current.filter((item) => !toRemove.has(item));
+    }
+    return parseArrayValue(value);
+}
+function formatArray(arr) {
+    return arr.length > 0 ? arr.join(', ') : '(none)';
+}
+/**
+ * Display current preferences in human-readable format.
+ */
+export function runConfigShow(options) {
+    const state = loadLocalState();
+    const prefs = state.preferences;
+    if (options.json) {
+        // JSON output handled by caller
+        return;
+    }
+    console.log('\n⚙️  oss-scout preferences\n');
+    console.log(`  githubUsername:        ${prefs.githubUsername || '(not set)'}`);
+    console.log(`  languages:            ${formatArray(prefs.languages)}`);
+    console.log(`  labels:               ${formatArray(prefs.labels)}`);
+    console.log(`  scope:                ${prefs.scope ? formatArray(prefs.scope) : '(all)'}`);
+    console.log(`  minStars:             ${prefs.minStars}`);
+    console.log(`  maxIssueAgeDays:      ${prefs.maxIssueAgeDays}`);
+    console.log(`  minRepoScoreThreshold: ${prefs.minRepoScoreThreshold}`);
+    console.log(`  includeDocIssues:     ${prefs.includeDocIssues}`);
+    console.log(`  preferredOrgs:        ${formatArray(prefs.preferredOrgs)}`);
+    console.log(`  projectCategories:    ${formatArray(prefs.projectCategories)}`);
+    console.log(`  excludeRepos:         ${formatArray(prefs.excludeRepos)}`);
+    console.log(`  aiPolicyBlocklist:    ${formatArray(prefs.aiPolicyBlocklist)}`);
+    console.log(`  persistence:          ${prefs.persistence}`);
+    console.log();
+}
+/**
+ * Get current preferences for JSON output.
+ */
+export function getConfigData() {
+    const state = loadLocalState();
+    return state.preferences;
+}
+/**
+ * Update a single preference by key.
+ */
+export function runConfigSet(key, value) {
+    if (!ALL_FIELDS.has(key)) {
+        throw new ValidationError(`Unknown config key: "${key}". Valid keys: ${[...ALL_FIELDS].sort().join(', ')}`);
+    }
+    const state = loadLocalState();
+    const prefs = { ...state.preferences };
+    if (STRING_FIELDS.has(key)) {
+        prefs[key] = value;
+    }
+    else if (BOOLEAN_FIELDS.has(key)) {
+        prefs[key] = parseBoolean(value);
+    }
+    else if (NUMBER_FIELDS.has(key)) {
+        prefs[key] = parseNumber(value, key);
+    }
+    else if (key === SCOPE_FIELD) {
+        const updated = updateArray(prefs.scope ?? [], value);
+        const invalid = updated.filter((s) => !VALID_SCOPES.includes(s));
+        if (invalid.length > 0) {
+            throw new ValidationError(`Invalid scope value(s): ${invalid.join(', ')}. Valid: ${VALID_SCOPES.join(', ')}`);
+        }
+        prefs.scope = updated.length > 0 ? updated : undefined;
+    }
+    else if (key === 'projectCategories') {
+        const updated = updateArray(prefs.projectCategories, value);
+        const invalid = updated.filter((s) => !VALID_CATEGORIES.includes(s));
+        if (invalid.length > 0) {
+            throw new ValidationError(`Invalid category value(s): ${invalid.join(', ')}. Valid: ${VALID_CATEGORIES.join(', ')}`);
+        }
+        prefs.projectCategories = updated;
+    }
+    else if (key in ENUM_FIELDS) {
+        const validValues = ENUM_FIELDS[key];
+        if (!validValues.includes(value)) {
+            throw new ValidationError(`Invalid value for "${key}": "${value}". Valid: ${validValues.join(', ')}`);
+        }
+        prefs[key] = value;
+    }
+    else if (ARRAY_FIELDS.has(key)) {
+        const current = prefs[key] ?? [];
+        prefs[key] = updateArray(current, value);
+    }
+    // Validate the full preferences object
+    const validated = ScoutPreferencesSchema.parse(prefs);
+    state.preferences = validated;
+    saveLocalState(state);
+    return validated;
+}
+/**
+ * Reset preferences to defaults.
+ */
+export function runConfigReset() {
+    const state = loadLocalState();
+    const defaults = ScoutPreferencesSchema.parse({});
+    state.preferences = defaults;
+    saveLocalState(state);
+    return defaults;
+}

package/dist/commands/results.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Results command — display and manage saved search results.
+ */
+import type { SavedCandidate } from '../core/schemas.js';
+export declare function runResults(_options: {
+    json?: boolean;
+}): Promise<SavedCandidate[]>;
+export declare function runResultsClear(): Promise<void>;

package/dist/commands/results.js

@@ -0,0 +1,13 @@
+/**
+ * Results command — display and manage saved search results.
+ */
+import { loadLocalState, saveLocalState } from '../core/local-state.js';
+export async function runResults(_options) {
+    const state = loadLocalState();
+    return state.savedResults ?? [];
+}
+export async function runResultsClear() {
+    const state = loadLocalState();
+    state.savedResults = [];
+    saveLocalState(state);
+}

package/dist/commands/search.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Search command — finds contributable issues using multi-strategy search.
+ */
+import type { ScoutState, SearchStrategy } from '../core/schemas.js';
+export interface SearchOutput {
+    candidates: Array<{
+        issue: {
+            repo: string;
+            repoUrl: string;
+            number: number;
+            title: string;
+            url: string;
+            labels: string[];
+        };
+        recommendation: 'approve' | 'skip' | 'needs_review';
+        reasonsToApprove: string[];
+        reasonsToSkip: string[];
+        searchPriority: string;
+        viabilityScore: number;
+        repoScore?: {
+            score: number;
+            mergedPRCount: number;
+            closedWithoutMergeCount: number;
+            isResponsive: boolean;
+            lastMergedAt?: string;
+        };
+    }>;
+    excludedRepos: string[];
+    aiPolicyBlocklist: string[];
+    rateLimitWarning?: string;
+    strategiesUsed: SearchStrategy[];
+}
+interface SearchCommandOptions {
+    maxResults: number;
+    state?: ScoutState;
+    strategies?: SearchStrategy[];
+}
+export declare function runSearch(options: SearchCommandOptions): Promise<SearchOutput>;
+export {};

package/dist/commands/search.js

@@ -0,0 +1,50 @@
+/**
+ * Search command — finds contributable issues using multi-strategy search.
+ */
+import { createScout } from '../scout.js';
+import { requireGitHubToken } from '../core/utils.js';
+import { saveLocalState } from '../core/local-state.js';
+export async function runSearch(options) {
+    const token = requireGitHubToken();
+    const scout = options.state
+        ? await createScout({ githubToken: token, persistence: 'provided', initialState: options.state })
+        : await createScout({ githubToken: token });
+    const result = await scout.search({ maxResults: options.maxResults, strategies: options.strategies });
+    // Persist results to local state and gist
+    scout.saveResults(result.candidates);
+    saveLocalState(scout.getState());
+    await scout.checkpoint();
+    return {
+        candidates: result.candidates.map((c) => {
+            const repoScoreRecord = scout.getRepoScoreRecord(c.issue.repo);
+            return {
+                issue: {
+                    repo: c.issue.repo,
+                    repoUrl: `https://github.com/${c.issue.repo}`,
+                    number: c.issue.number,
+                    title: c.issue.title,
+                    url: c.issue.url,
+                    labels: c.issue.labels,
+                },
+                recommendation: c.recommendation,
+                reasonsToApprove: c.reasonsToApprove,
+                reasonsToSkip: c.reasonsToSkip,
+                searchPriority: c.searchPriority,
+                viabilityScore: c.viabilityScore,
+                repoScore: repoScoreRecord
+                    ? {
+                        score: repoScoreRecord.score,
+                        mergedPRCount: repoScoreRecord.mergedPRCount,
+                        closedWithoutMergeCount: repoScoreRecord.closedWithoutMergeCount,
+                        isResponsive: repoScoreRecord.signals?.isResponsive ?? false,
+                        lastMergedAt: repoScoreRecord.lastMergedAt,
+                    }
+                    : undefined,
+            };
+        }),
+        excludedRepos: result.excludedRepos,
+        aiPolicyBlocklist: result.aiPolicyBlocklist,
+        rateLimitWarning: result.rateLimitWarning,
+        strategiesUsed: result.strategiesUsed,
+    };
+}

package/dist/commands/setup.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Setup command — interactive first-run configuration for oss-scout.
+ */
+import type { ScoutPreferences } from '../core/schemas.js';
+interface ReadlineInterface {
+    question(query: string, callback: (answer: string) => void): void;
+    close(): void;
+}
+export interface SetupOptions {
+    rl?: ReadlineInterface;
+    detectUsername?: () => Promise<string>;
+}
+/**
+ * Run the interactive setup flow and return the configured preferences.
+ */
+export declare function runSetup(options?: SetupOptions): Promise<ScoutPreferences>;
+export {};