@vibemastery/zurf 0.2.3 → 0.3.0

package/README.md

@@ -1,7 +1,7 @@
 zurf
 =================
 
-A lightweight CLI for searching, browsing, and fetching web pages, powered by Browserbase.
+A lightweight CLI for searching, browsing, and fetching web pages (Browserbase) and asking AI-powered questions with web citations (Perplexity Sonar).
 
 
 [![oclif](https://img.shields.io/badge/cli-oclif-brightgreen.svg)](https://oclif.io)
@@ -12,12 +12,33 @@ A lightweight CLI for searching, browsing, and fetching web pages, powered by Br
 
 ```sh-session
 $ npm install -g @vibemastery/zurf
-$ zurf init --global          # save your Browserbase API key
+$ zurf setup                       # configure API keys (Browserbase, Perplexity)
 $ zurf --help
 ```
 
 ## Commands
 
+### `zurf ask <question>`
+
+Ask a question and get an AI-powered answer with web citations via Perplexity Sonar. Use `--depth deep` for more thorough research (sonar-pro).
+
+```sh-session
+$ zurf ask "What is Browserbase?"
+$ zurf ask "latest tech news" --recency day
+$ zurf ask "search reddit for best CLI tools" --domains reddit.com
+$ zurf ask "explain quantum computing" --depth deep
+$ zurf ask "What is Node.js?" --json
+$ zurf ask "What is oclif?" --no-citations
+```
+
+| Flag | Description |
+|------|-------------|
+| `--depth <quick\|deep>` | Search depth: quick (sonar) or deep (sonar-pro). Default: quick |
+| `--recency <hour\|day\|week\|month\|year>` | Filter sources by recency |
+| `--domains <list>` | Restrict search to these domains (comma-separated) |
+| `--no-citations` | Hide the sources list after the answer |
+| `--json` | Print machine-readable JSON to stdout |
+
 ### `zurf search <query>`
 
 Search the web via Browserbase (Exa-powered). Returns a list of matching URLs with titles and snippets.
@@ -72,20 +93,19 @@ $ zurf fetch https://example.com --json        # JSON with content + metadata
 | `--allow-insecure-ssl` | Disable TLS certificate verification |
 | `--json` | Print machine-readable JSON to stdout |
 
-### `zurf init`
+### `zurf setup`
 
-Save your Browserbase API key and optional Project ID to a config file.
+Interactive wizard to configure API keys for all providers (Browserbase, Perplexity). Stores keys in global or local config. Re-run to update or add providers.
 
 ```sh-session
-$ zurf init --global                              # save to global config
-$ zurf init --local                               # save to project .zurf/config.json
-$ zurf init --local --gitignore                   # also append .zurf/ to .gitignore
-$ zurf init --global --project-id <project-id>    # save project ID too
+$ zurf setup                # interactive wizard
+$ zurf setup --global       # skip scope prompt, save to global config
+$ zurf setup --local        # skip scope prompt, save to project .zurf/config.json
 ```
 
 ### `zurf config which`
 
-Show where your API key and Project ID would be loaded from (nothing secret is printed).
+Show where your API keys would be loaded from (nothing secret is printed). Shows resolution for both Browserbase and Perplexity.
 
 ```sh-session
 $ zurf config which
@@ -112,22 +132,53 @@ Format resolution (highest precedence first):
 
 ## Configuration
 
-API key resolution (highest precedence first):
+### Config file structure (v0.3.0+)
 
+```json
+{
+  "providers": {
+    "browserbase": {
+      "apiKey": "bb_...",
+      "projectId": "proj_..."
+    },
+    "perplexity": {
+      "apiKey": "pplx-..."
+    }
+  },
+  "format": "markdown"
+}
+```
+
+Old flat configs (v0.2.x) are auto-migrated when read — no manual action needed.
+
+### API key resolution
+
+Each provider resolves its key independently (highest precedence first):
+
+**Browserbase:**
 1. Environment variable `BROWSERBASE_API_KEY`
-2. Nearest `.zurf/config.json` when walking up from the current working directory
-3. Global config: `$XDG_CONFIG_HOME/zurf/config.json` (or `~/.config/zurf/config.json`)
+2. Nearest `.zurf/config.json` → `providers.browserbase.apiKey`
+3. Global config → `providers.browserbase.apiKey`
+
+**Perplexity:**
+1. Environment variable `PERPLEXITY_API_KEY`
+2. Nearest `.zurf/config.json` → `providers.perplexity.apiKey`
+3. Global config → `providers.perplexity.apiKey`
 
-Save a key interactively:
+Save keys interactively:
 
 ```sh-session
-$ zurf init --global
-$ zurf init --local
+$ zurf setup
 ```
 
-For project-local storage, add `.zurf/` to `.gitignore` so the key is never committed. You can run `zurf init --local --gitignore` to append a `.zurf/` entry automatically.
+For project-local storage, add `.zurf/` to `.gitignore` so keys are never committed. `zurf setup --local` will offer to do this automatically.
+
+**Security note:** Keys in `config.json` are stored as plaintext with file mode `0o600`. For shared machines or stricter setups, prefer environment variables from a secrets manager.
+
+### Migration from v0.2.x
 
-**Security note:** Keys in `config.json` are stored as plaintext with file mode `0o600`. For shared machines or stricter setups, prefer `BROWSERBASE_API_KEY` from your environment or a secrets manager instead of `init`.
+- Config files auto-migrate from the old flat shape (`{ "apiKey": "..." }`) to the new nested shape. No manual changes needed.
+- `zurf init` has been replaced by `zurf setup`. The setup wizard supports multiple providers.
 
 ## Claude Code and agents
 
@@ -137,6 +188,7 @@ Install `zurf` on your `PATH` and allow the agent to run shell commands. Use `--
 $ zurf search "browserbase fetch api" --json
 $ zurf browse https://example.com --json
 $ zurf fetch https://example.com --json
+$ zurf ask "What is Browserbase?" --json
 ```
 
 Content is returned as markdown by default, which keeps token counts low. Pass `--html` if the agent needs the raw DOM.

package/dist/commands/ask/index.d.ts

@@ -0,0 +1,17 @@
+import { Command } from '@oclif/core';
+export default class Ask extends Command {
+    static args: {
+        question: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        citations: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        depth: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        domains: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        recency: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static summary: string;
+    run(): Promise<void>;
+}

package/dist/commands/ask/index.js

@@ -0,0 +1,102 @@
+import { Args, Command, Flags, ux } from '@oclif/core';
+import { cliError, errorMessage } from '../../lib/cli-errors.js';
+import { zurfJsonFlag } from '../../lib/flags.js';
+import { printJson } from '../../lib/json-output.js';
+import { createPerplexityClient, MissingPerplexityKeyError, } from '../../lib/perplexity-client.js';
+export default class Ask extends Command {
+    static args = {
+        question: Args.string({
+            description: 'The question to ask Perplexity',
+            required: true,
+        }),
+    };
+    static description = `Ask a question and get an AI-powered answer with web citations via Perplexity Sonar.
+Returns an answer with inline citations and a sources list. Use --depth deep for more thorough research.`;
+    static examples = [
+        '<%= config.bin %> <%= command.id %> "What is Browserbase?"',
+        '<%= config.bin %> <%= command.id %> "latest tech news" --recency day',
+        '<%= config.bin %> <%= command.id %> "search reddit for best CLI tools" --domains reddit.com',
+        '<%= config.bin %> <%= command.id %> "explain quantum computing" --depth deep',
+        '<%= config.bin %> <%= command.id %> "What is Node.js?" --json',
+        '<%= config.bin %> <%= command.id %> "What is oclif?" --no-citations',
+    ];
+    static flags = {
+        citations: Flags.boolean({
+            allowNo: true,
+            default: true,
+            description: 'Show sources list after the answer (use --no-citations to hide)',
+        }),
+        depth: Flags.string({
+            default: 'quick',
+            description: 'Search depth: quick (sonar) or deep (sonar-pro)',
+            options: ['quick', 'deep'],
+        }),
+        domains: Flags.string({
+            description: 'Restrict search to these domains (comma-separated)',
+        }),
+        json: zurfJsonFlag,
+        recency: Flags.string({
+            description: 'Filter sources by recency',
+            options: ['hour', 'day', 'week', 'month', 'year'],
+        }),
+    };
+    static summary = 'Ask a question via Perplexity Sonar';
+    async run() {
+        const { args, flags } = await this.parse(Ask);
+        const question = args.question.trim();
+        if (question.length === 0) {
+            cliError({ command: this, exitCode: 2, json: flags.json, message: 'Question must not be empty.' });
+        }
+        let client;
+        try {
+            ;
+            ({ client } = createPerplexityClient({ globalConfigDir: this.config.configDir }));
+        }
+        catch (error) {
+            if (error instanceof MissingPerplexityKeyError) {
+                cliError({ command: this, exitCode: 1, json: flags.json, message: error.message });
+            }
+            throw error;
+        }
+        const domains = flags.domains?.split(',').map((d) => d.trim()).filter(Boolean);
+        const doWork = async () => {
+            const result = await client.ask({
+                depth: flags.depth,
+                domains,
+                question,
+                recency: flags.recency,
+            });
+            if (flags.json) {
+                printJson({ answer: result.answer, citations: result.citations, model: result.model, query: question });
+                return;
+            }
+            this.log(result.answer);
+            if (flags.citations && result.citations.length > 0) {
+                this.log('');
+                this.log('Sources:');
+                for (const [i, url] of result.citations.entries()) {
+                    this.log(`[${i + 1}] ${url}`);
+                }
+            }
+        };
+        if (flags.json) {
+            try {
+                await doWork();
+            }
+            catch (error) {
+                cliError({ command: this, exitCode: 1, json: flags.json, message: errorMessage(error) });
+            }
+            return;
+        }
+        ux.action.start('Asking Perplexity');
+        try {
+            await doWork();
+        }
+        catch (error) {
+            cliError({ command: this, exitCode: 1, json: flags.json, message: errorMessage(error) });
+        }
+        finally {
+            ux.action.stop();
+        }
+    }
+}

package/dist/commands/browse/index.js

@@ -18,7 +18,7 @@ export default class Browse extends ZurfBrowserbaseCommand {
     };
     static description = `Browse a URL in a cloud browser and return the rendered content as markdown (default) or raw HTML.
 Uses a real Chromium browser via Browserbase, so JavaScript-heavy pages are fully rendered.
-Requires authentication and a Project ID. Run \`zurf init --global\` before first use.`;
+Requires authentication and a Project ID. Run \`zurf setup\` before first use.`;
     static examples = [
         '<%= config.bin %> <%= command.id %> https://example.com',
         '<%= config.bin %> <%= command.id %> https://example.com --html',
@@ -57,7 +57,7 @@ Requires authentication and a Project ID. Run \`zurf init --global\` before firs
         await this.runWithBrowserbase(flags, `Browsing ${url}`, async (client) => {
             const resolution = resolveProjectId({ globalConfigDir: this.config.configDir });
             if (resolution.source === 'none') {
-                throw new Error('No Browserbase Project ID found. Set BROWSERBASE_PROJECT_ID, run `zurf init --global` with --project-id, or add projectId to your .zurf/config.json.');
+                throw new Error('No Browserbase Project ID found. Set BROWSERBASE_PROJECT_ID, run `zurf setup` with --project-id, or add projectId to your .zurf/config.json.');
             }
             const { projectId } = resolution;
             const result = await withBrowserbaseSession({

package/dist/commands/config/which.js

@@ -1,61 +1,68 @@
 import { Command } from '@oclif/core';
-import { globalConfigFilePath, resolveApiKey } from '../../lib/config.js';
+import { globalConfigFilePath, resolveApiKey, resolvePerplexityApiKey } from '../../lib/config.js';
 import { zurfBaseFlags } from '../../lib/flags.js';
 import { printJson } from '../../lib/json-output.js';
+function resolvedSource(resolved) {
+    switch (resolved.source) {
+        case 'env': {
+            return { source: 'env' };
+        }
+        case 'global':
+        case 'local': {
+            return { path: resolved.path, source: resolved.source };
+        }
+        default: {
+            return { source: 'none' };
+        }
+    }
+}
+function humanSourceLine(label, resolved, envVarName) {
+    switch (resolved.source) {
+        case 'env': {
+            return `${label}: environment variable ${envVarName}`;
+        }
+        case 'global': {
+            return `${label}: global file ${resolved.path}`;
+        }
+        case 'local': {
+            return `${label}: local file ${resolved.path}`;
+        }
+        default: {
+            return `${label}: not configured`;
+        }
+    }
+}
 export default class ConfigWhich extends Command {
-    static description = `Show where the Browserbase API key would be loaded from (no secret printed).
-Resolution order: BROWSERBASE_API_KEY, then project .zurf/config.json (walk-up), then global config in the CLI config directory.`;
+    static description = `Show where API keys would be loaded from (no secrets printed).
+Resolution order: env var → project .zurf/config.json (walk-up) → global config.`;
     static examples = ['<%= config.bin %> config which', '<%= config.bin %> config which --json'];
     static flags = {
         ...zurfBaseFlags,
     };
-    static summary = 'Show where the API key is loaded from';
+    static summary = 'Show where API keys are loaded from';
     async run() {
         const { flags } = await this.parse(ConfigWhich);
-        const resolved = resolveApiKey({ globalConfigDir: this.config.configDir });
+        const bbResolved = resolveApiKey({ globalConfigDir: this.config.configDir });
+        const pplxResolved = resolvePerplexityApiKey({ globalConfigDir: this.config.configDir });
         if (flags.json) {
-            switch (resolved.source) {
-                case 'env': {
-                    printJson({ envVar: 'BROWSERBASE_API_KEY', source: 'env' });
-                    break;
-                }
-                case 'global': {
-                    printJson({ path: resolved.path, source: 'global' });
-                    break;
-                }
-                case 'local': {
-                    printJson({ path: resolved.path, source: 'local' });
-                    break;
-                }
-                case 'none': {
-                    printJson({
-                        globalConfigPath: globalConfigFilePath(this.config.configDir),
-                        hint: `Run \`${this.config.bin} init --global\` or \`${this.config.bin} init --local\`, or set BROWSERBASE_API_KEY.`,
-                        source: 'none',
-                    });
-                    this.exit(1);
-                    break;
-                }
+            const payload = {
+                browserbase: resolvedSource(bbResolved),
+                perplexity: resolvedSource(pplxResolved),
+            };
+            if (bbResolved.source === 'none' && pplxResolved.source === 'none') {
+                payload.globalConfigPath = globalConfigFilePath(this.config.configDir);
+                payload.hint = `Run \`${this.config.bin} setup\` or set BROWSERBASE_API_KEY / PERPLEXITY_API_KEY.`;
+            }
+            printJson(payload);
+            if (bbResolved.source === 'none' && pplxResolved.source === 'none') {
+                this.exit(1);
             }
             return;
         }
-        switch (resolved.source) {
-            case 'env': {
-                this.log('API key source: environment variable BROWSERBASE_API_KEY');
-                break;
-            }
-            case 'global': {
-                this.log(`API key source: global file ${resolved.path}`);
-                break;
-            }
-            case 'local': {
-                this.log(`API key source: local file ${resolved.path}`);
-                break;
-            }
-            case 'none': {
-                this.error(`No API key configured. Set BROWSERBASE_API_KEY or run \`${this.config.bin} init --global\` / \`--local\`.`);
-                break;
-            }
+        this.log(humanSourceLine('Browserbase API key', bbResolved, 'BROWSERBASE_API_KEY'));
+        this.log(humanSourceLine('Perplexity API key', pplxResolved, 'PERPLEXITY_API_KEY'));
+        if (bbResolved.source === 'none' && pplxResolved.source === 'none') {
+            this.error(`No API keys configured. Run \`${this.config.bin} setup\` or set environment variables.`);
         }
     }
 }

package/dist/commands/fetch/index.js

@@ -16,7 +16,7 @@ export default class Fetch extends ZurfBrowserbaseCommand {
         }),
     };
     static description = `Fetch a URL via Browserbase and return content as markdown (default) or raw HTML (no browser session; static HTML, 1 MB max).
-Requires authentication. Run \`zurf init --global\` or use a project key before first use.`;
+Requires authentication. Run \`zurf setup\` or use a project key before first use.`;
     static examples = [
         '<%= config.bin %> <%= command.id %> https://example.com',
         '<%= config.bin %> <%= command.id %> https://example.com --html',

package/dist/commands/search/index.js

@@ -12,7 +12,7 @@ export default class Search extends ZurfBrowserbaseCommand {
         }),
     };
     static description = `Search the web via Browserbase (Exa-powered).
-Requires authentication. Run \`zurf init --global\` or use a project key before first use.`;
+Requires authentication. Run \`zurf setup\` or use a project key before first use.`;
     static examples = [
         '<%= config.bin %> <%= command.id %> "browserbase documentation"',
         '<%= config.bin %> <%= command.id %> "laravel inertia" --num-results 5 --json',

package/dist/commands/setup/index.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class Setup extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        global: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        local: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static summary: string;
+    run(): Promise<void>;
+    private collectProviderKeys;
+    private suggestGitignore;
+}

package/dist/commands/setup/index.js

@@ -0,0 +1,123 @@
+import { Command, Flags } from '@oclif/core';
+import * as fs from 'node:fs/promises';
+import { cliError, errorMessage } from '../../lib/cli-errors.js';
+import { globalConfigFilePath, localConfigPathForCwd, readConfigFile, writeConfig, } from '../../lib/config.js';
+import { zurfJsonFlag } from '../../lib/flags.js';
+import { dotGitignoreMentionsZurf, ensureZurfGitignoreEntry, gitignorePathForCwd, } from '../../lib/gitignore-zurf.js';
+import { printJson } from '../../lib/json-output.js';
+import { promptApiKey, promptProjectId, selectProviders, selectScope, } from '../../lib/setup-prompts.js';
+async function promptBrowserbase() {
+    const apiKey = await promptApiKey('Browserbase');
+    const projectId = await promptProjectId();
+    const browserbase = { apiKey: apiKey.trim() };
+    if (projectId.trim()) {
+        browserbase.projectId = projectId.trim();
+    }
+    return { configured: 'Browserbase', providers: { browserbase } };
+}
+async function promptPerplexity() {
+    const apiKey = await promptApiKey('Perplexity');
+    return { configured: 'Perplexity', providers: { perplexity: { apiKey: apiKey.trim() } } };
+}
+function resolveScope(flags) {
+    if (flags.global)
+        return 'global';
+    if (flags.local)
+        return 'local';
+    return undefined;
+}
+export default class Setup extends Command {
+    static description = `Interactive setup wizard for configuring API keys for all providers (Browserbase, Perplexity).
+Stores keys in global or local config. Re-run to update or add providers.`;
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --global',
+        '<%= config.bin %> <%= command.id %> --local',
+    ];
+    static flags = {
+        global: Flags.boolean({
+            description: 'Store config in user config directory (skip scope prompt)',
+        }),
+        json: zurfJsonFlag,
+        local: Flags.boolean({
+            description: 'Store config in .zurf/config.json in the current directory (skip scope prompt)',
+        }),
+    };
+    static summary = 'Configure API keys for Browserbase and Perplexity';
+    async run() {
+        const { flags } = await this.parse(Setup);
+        if (flags.global && flags.local) {
+            cliError({ command: this, exitCode: 2, json: flags.json, message: 'Cannot use both --global and --local.' });
+        }
+        const scope = resolveScope(flags) ?? (process.stdin.isTTY
+            ? await selectScope()
+            : cliError({
+                command: this,
+                exitCode: 1,
+                json: flags.json,
+                message: 'Non-interactive environment detected. Use --global or --local flag, or set API keys via environment variables (BROWSERBASE_API_KEY, PERPLEXITY_API_KEY).',
+            }));
+        const targetPath = scope === 'global'
+            ? globalConfigFilePath(this.config.configDir)
+            : localConfigPathForCwd();
+        const existing = readConfigFile(targetPath);
+        const bbConfigured = Boolean(existing?.providers?.browserbase?.apiKey);
+        const pplxConfigured = Boolean(existing?.providers?.perplexity?.apiKey);
+        const selectedProviders = process.stdin.isTTY
+            ? await selectProviders([
+                { configured: bbConfigured, name: 'Browserbase', value: 'browserbase' },
+                { configured: pplxConfigured, name: 'Perplexity', value: 'perplexity' },
+            ])
+            : ['browserbase', 'perplexity'];
+        const { configUpdate, configured } = await this.collectProviderKeys(selectedProviders);
+        try {
+            await writeConfig(targetPath, configUpdate);
+        }
+        catch (error) {
+            cliError({ command: this, exitCode: 1, json: flags.json, message: errorMessage(error) });
+        }
+        if (flags.json) {
+            printJson({ configured, ok: true, path: targetPath, scope });
+            return;
+        }
+        for (const name of configured) {
+            this.log(`Configured ${name} in ${targetPath}`);
+        }
+        if (scope === 'local') {
+            await this.suggestGitignore();
+        }
+    }
+    async collectProviderKeys(selectedProviders) {
+        const configUpdate = { providers: {} };
+        const configured = [];
+        for (const provider of selectedProviders) {
+            // eslint-disable-next-line no-await-in-loop -- sequential prompts, must run in order
+            const result = provider === 'browserbase' ? await promptBrowserbase() : await promptPerplexity();
+            Object.assign(configUpdate.providers, result.providers);
+            configured.push(result.configured);
+        }
+        return { configUpdate, configured };
+    }
+    async suggestGitignore() {
+        let showTip = true;
+        try {
+            const gi = await fs.readFile(gitignorePathForCwd(), 'utf8');
+            if (dotGitignoreMentionsZurf(gi)) {
+                showTip = false;
+            }
+        }
+        catch {
+            // no .gitignore yet
+        }
+        if (showTip) {
+            this.log('Tip: add .zurf/ to .gitignore so keys are not committed.');
+            try {
+                await ensureZurfGitignoreEntry(gitignorePathForCwd());
+                this.log('Added .zurf/ to .gitignore.');
+            }
+            catch {
+                // best effort
+            }
+        }
+    }
+}

package/dist/lib/browserbase-client.js

@@ -10,7 +10,7 @@ export async function createBrowserbaseClient(options) {
 }
 export class MissingApiKeyError extends Error {
     constructor() {
-        super('No Browserbase API key found. Set BROWSERBASE_API_KEY, run `zurf init --global` or `zurf init --local`, or add a project `.zurf/config.json`.');
+        super('No Browserbase API key found. Set BROWSERBASE_API_KEY, run `zurf setup`, or add a project `.zurf/config.json`.');
         this.name = 'MissingApiKeyError';
     }
 }

package/dist/lib/config.d.ts

@@ -18,11 +18,25 @@ export type ResolvedApiKey = {
 export type ActiveApiKey = Extract<ResolvedApiKey, {
     apiKey: string;
 }>;
-export interface ConfigFileShape {
+/** Old flat config shape (v0.2.x and earlier). */
+export interface LegacyConfigFileShape {
     apiKey?: string;
     format?: 'html' | 'markdown';
     projectId?: string;
 }
+/** Current config shape (v0.3.0+). */
+export interface ConfigFileShape {
+    format?: 'html' | 'markdown';
+    providers?: {
+        browserbase?: {
+            apiKey?: string;
+            projectId?: string;
+        };
+        perplexity?: {
+            apiKey?: string;
+        };
+    };
+}
 export type ResolvedProjectId = {
     path: string;
     projectId: string;
@@ -37,12 +51,15 @@ export type ResolvedProjectId = {
 } | {
     source: 'none';
 };
+/** Alias — structurally identical to ResolvedApiKey; kept for semantic clarity at call sites. */
+export type ResolvedPerplexityApiKey = ResolvedApiKey;
 /**
  * Path to global `config.json` under oclif's `this.config.configDir` (same rules as @oclif/core `Config.dir('config')` for `dirname` zurf).
  */
 export declare function globalConfigFilePath(oclifConfigDir: string): string;
 export declare function localConfigPathForCwd(cwd?: string): string;
 export declare function findLocalConfigPath(startDir?: string): string | undefined;
+export declare function readConfigFile(filePath: string): ConfigFileShape | undefined;
 export declare function resolveFormat(options: {
     cwd?: string;
     flagHtml: boolean;
@@ -56,5 +73,9 @@ export declare function resolveProjectId(options: {
     cwd?: string;
     globalConfigDir: string;
 }): ResolvedProjectId;
+export declare function resolvePerplexityApiKey(options: {
+    cwd?: string;
+    globalConfigDir: string;
+}): ResolvedPerplexityApiKey;
 export declare function writeApiKeyConfig(targetPath: string, apiKey: string): Promise<void>;
 export declare function writeConfig(targetPath: string, fields: Partial<ConfigFileShape>): Promise<void>;