@vibemastery/zurf 0.1.0

package/dist/commands/fetch/index.js

@@ -0,0 +1,111 @@
+import { Args, Flags } from '@oclif/core';
+import * as fs from 'node:fs/promises';
+import path from 'node:path';
+import { cliError } from '../../lib/cli-errors.js';
+import { buildFetchJsonPayload, HUMAN_BODY_PREVIEW_CHARS, humanFetchMetaLines, truncateNote, } from '../../lib/fetch-output.js';
+import { zurfBaseFlags } from '../../lib/flags.js';
+import { printJson } from '../../lib/json-output.js';
+import { ZurfBrowserbaseCommand } from '../../lib/zurf-browserbase-command.js';
+export default class Fetch extends ZurfBrowserbaseCommand {
+    static args = {
+        url: Args.string({
+            description: 'URL to fetch',
+            required: true,
+        }),
+    };
+    static description = `Fetch a URL via Browserbase (no browser session; static HTML, 1 MB max).
+Requires authentication. Run \`zurf init --global\` or use a project key before first use.`;
+    static examples = [
+        '<%= config.bin %> <%= command.id %> https://example.com',
+        '<%= config.bin %> <%= command.id %> https://example.com --json',
+        '<%= config.bin %> <%= command.id %> https://example.com -o page.html --proxies',
+    ];
+    static flags = {
+        ...zurfBaseFlags,
+        'allow-insecure-ssl': Flags.boolean({
+            default: false,
+            description: 'Disable TLS certificate verification (use only if you trust the target)',
+        }),
+        'allow-redirects': Flags.boolean({
+            default: false,
+            description: 'Follow HTTP redirects',
+        }),
+        output: Flags.string({
+            char: 'o',
+            description: 'Write response body to this file (full content); otherwise human mode prints a truncated preview to stdout',
+        }),
+        proxies: Flags.boolean({
+            default: false,
+            description: 'Route through Browserbase proxies (helps with some blocked sites)',
+        }),
+    };
+    static summary = 'Fetch a URL via Browserbase';
+    async run() {
+        const { args, flags } = await this.parse(Fetch);
+        const url = args.url.trim();
+        let parsed;
+        try {
+            parsed = new URL(url);
+        }
+        catch {
+            cliError({ command: this, exitCode: 2, json: flags.json, message: `Invalid URL: ${url}` });
+        }
+        if (!['http:', 'https:'].includes(parsed.protocol)) {
+            cliError({
+                command: this,
+                exitCode: 2,
+                json: flags.json,
+                message: `Only http and https URLs are supported: ${url}`,
+            });
+        }
+        if (!parsed.hostname) {
+            cliError({ command: this, exitCode: 2, json: flags.json, message: `Invalid URL: ${url}` });
+        }
+        await this.runWithBrowserbase(flags, 'Fetching URL', async (client) => {
+            const response = await client.fetchAPI.create({
+                allowInsecureSsl: flags['allow-insecure-ssl'],
+                allowRedirects: flags['allow-redirects'],
+                proxies: flags.proxies,
+                url,
+            });
+            if (flags.json) {
+                printJson(buildFetchJsonPayload(response));
+                return;
+            }
+            this.logToStderr(humanFetchMetaLines(response).join('\n'));
+            this.logToStderr('');
+            if (flags.output) {
+                try {
+                    await fs.writeFile(flags.output, response.content, 'utf8');
+                }
+                catch (error) {
+                    const code = error !== null &&
+                        typeof error === 'object' &&
+                        'code' in error &&
+                        typeof error.code === 'string'
+                        ? error.code
+                        : undefined;
+                    if (code === 'ENOENT') {
+                        cliError({
+                            command: this,
+                            exitCode: 1,
+                            json: flags.json,
+                            message: `Directory does not exist for output file: ${path.dirname(path.resolve(flags.output))}`,
+                        });
+                    }
+                    throw error;
+                }
+                this.logToStderr(`Wrote body to ${flags.output}`);
+                return;
+            }
+            const { content } = response;
+            if (content.length <= HUMAN_BODY_PREVIEW_CHARS) {
+                this.log(content);
+                return;
+            }
+            this.log(content.slice(0, HUMAN_BODY_PREVIEW_CHARS));
+            this.log('');
+            this.logToStderr(truncateNote(content.length));
+        });
+    }
+}

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

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+export default class Init extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'api-key': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        gitignore: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        global: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        local: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static summary: string;
+    run(): Promise<void>;
+    private readApiKeyForInit;
+}

package/dist/commands/init/index.js

@@ -0,0 +1,95 @@
+import { Command, Flags } from '@oclif/core';
+import * as fs from 'node:fs/promises';
+import { cliError, errorMessage } from '../../lib/cli-errors.js';
+import { globalConfigFilePath, localConfigPathForCwd, writeApiKeyConfig } from '../../lib/config.js';
+import { zurfBaseFlags } from '../../lib/flags.js';
+import { dotGitignoreMentionsZurf, ensureZurfGitignoreEntry, gitignorePathForCwd, } from '../../lib/gitignore-zurf.js';
+import { promptLine, readStdinIfPiped } from '../../lib/init-input.js';
+import { printJson } from '../../lib/json-output.js';
+export default class Init extends Command {
+    static description = `Save your Browserbase API key to global or project config.
+Global path follows oclif config (same as \`zurf config which\`).`;
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --global',
+        '<%= config.bin %> <%= command.id %> --local',
+        'printenv BROWSERBASE_API_KEY | <%= config.bin %> <%= command.id %> --global',
+    ];
+    static flags = {
+        ...zurfBaseFlags,
+        'api-key': Flags.string({
+            description: 'API key for non-interactive use. Prefer piping stdin or using a TTY prompt — values on the command line are visible in shell history and process listings.',
+        }),
+        gitignore: Flags.boolean({
+            description: 'Append .zurf/ to ./.gitignore if that entry is missing',
+        }),
+        global: Flags.boolean({
+            description: 'Store API key in user config (oclif config dir for this CLI)',
+            exactlyOne: ['global', 'local'],
+        }),
+        local: Flags.boolean({
+            description: 'Store API key in ./.zurf/config.json for this directory',
+            exactlyOne: ['global', 'local'],
+        }),
+    };
+    static summary = 'Configure Browserbase API key storage';
+    async run() {
+        const { flags } = await this.parse(Init);
+        const apiKey = await this.readApiKeyForInit(flags);
+        const targetPath = flags.global
+            ? globalConfigFilePath(this.config.configDir)
+            : localConfigPathForCwd();
+        try {
+            await writeApiKeyConfig(targetPath, apiKey);
+        }
+        catch (error) {
+            cliError({ command: this, exitCode: 1, json: flags.json, message: errorMessage(error) });
+        }
+        if (flags.gitignore) {
+            try {
+                await ensureZurfGitignoreEntry(gitignorePathForCwd());
+            }
+            catch (error) {
+                cliError({ command: this, exitCode: 1, json: flags.json, message: errorMessage(error) });
+            }
+        }
+        if (flags.json) {
+            printJson({ ok: true, path: targetPath, scope: flags.global ? 'global' : 'local' });
+        }
+        else {
+            this.log(`Saved API key to ${targetPath}`);
+            if (flags.local) {
+                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 the key is not committed (or run with --gitignore).');
+                }
+            }
+        }
+    }
+    async readApiKeyForInit(flags) {
+        let apiKey = flags['api-key']?.trim();
+        if (!apiKey) {
+            apiKey = await readStdinIfPiped();
+        }
+        if (!apiKey && process.stdin.isTTY) {
+            apiKey = await promptLine('Browserbase API key: ');
+        }
+        if (!apiKey) {
+            cliError({
+                command: this,
+                exitCode: 2,
+                json: flags.json,
+                message: 'No API key provided. Pipe stdin, use --api-key, or run interactively in a TTY.',
+            });
+        }
+        return apiKey;
+    }
+}

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

@@ -0,0 +1,14 @@
+import { ZurfBrowserbaseCommand } from '../../lib/zurf-browserbase-command.js';
+export default class Search extends ZurfBrowserbaseCommand {
+    static args: {
+        query: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'num-results': import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static summary: string;
+    run(): Promise<void>;
+}

package/dist/commands/search/index.js

@@ -0,0 +1,59 @@
+import { Args, Flags } from '@oclif/core';
+import { cliError } from '../../lib/cli-errors.js';
+import { zurfBaseFlags } from '../../lib/flags.js';
+import { printJson } from '../../lib/json-output.js';
+import { buildSearchJsonPayload, linesForHumanSearch } from '../../lib/search-output.js';
+import { ZurfBrowserbaseCommand } from '../../lib/zurf-browserbase-command.js';
+export default class Search extends ZurfBrowserbaseCommand {
+    static args = {
+        query: Args.string({
+            description: 'Search query, max 200 characters (quote for multiple words)',
+            required: true,
+        }),
+    };
+    static description = `Search the web via Browserbase (Exa-powered).
+Requires authentication. Run \`zurf init --global\` 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',
+    ];
+    static flags = {
+        ...zurfBaseFlags,
+        'num-results': Flags.integer({
+            char: 'n',
+            default: 10,
+            description: 'Number of results (1–25)',
+            max: 25,
+            min: 1,
+        }),
+    };
+    static summary = 'Search the web via Browserbase';
+    async run() {
+        const { args, flags } = await this.parse(Search);
+        const query = args.query.trim();
+        if (query.length === 0) {
+            cliError({ command: this, exitCode: 2, json: flags.json, message: 'Query must not be empty.' });
+        }
+        if (query.length > 200) {
+            cliError({
+                command: this,
+                exitCode: 2,
+                json: flags.json,
+                message: 'Query must be at most 200 characters.',
+            });
+        }
+        await this.runWithBrowserbase(flags, 'Searching the web', async (client) => {
+            const response = await client.search.web({
+                numResults: flags['num-results'],
+                query,
+            });
+            if (flags.json) {
+                printJson(buildSearchJsonPayload(response));
+                return;
+            }
+            for (const line of linesForHumanSearch(response)) {
+                this.log(line);
+            }
+        });
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/lib/browserbase-client.d.ts

@@ -0,0 +1,12 @@
+import type { Browserbase } from '@browserbasehq/sdk';
+import { type ActiveApiKey } from './config.js';
+export declare function createBrowserbaseClient(options: {
+    cwd?: string;
+    globalConfigDir: string;
+}): Promise<{
+    client: Browserbase;
+    resolution: ActiveApiKey;
+}>;
+export declare class MissingApiKeyError extends Error {
+    constructor();
+}

package/dist/lib/browserbase-client.js

@@ -0,0 +1,16 @@
+import { resolveApiKey } from './config.js';
+export async function createBrowserbaseClient(options) {
+    const { Browserbase } = await import('@browserbasehq/sdk');
+    const resolution = resolveApiKey({ cwd: options.cwd, globalConfigDir: options.globalConfigDir });
+    if (resolution.source === 'none') {
+        throw new MissingApiKeyError();
+    }
+    const client = new Browserbase({ apiKey: resolution.apiKey });
+    return { client, resolution };
+}
+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`.');
+        this.name = 'MissingApiKeyError';
+    }
+}

package/dist/lib/browserbase-command.d.ts

@@ -0,0 +1,8 @@
+import type { Command } from '@oclif/core';
+import { createBrowserbaseClient } from './browserbase-client.js';
+export declare function getBrowserbaseClientOrExit(command: Command, flags: {
+    json: boolean;
+}, options: {
+    cwd?: string;
+    globalConfigDir: string;
+}): Promise<Awaited<ReturnType<typeof createBrowserbaseClient>>>;

package/dist/lib/browserbase-command.js

@@ -0,0 +1,16 @@
+import { createBrowserbaseClient, MissingApiKeyError } from './browserbase-client.js';
+import { cliError } from './cli-errors.js';
+export async function getBrowserbaseClientOrExit(command, flags, options) {
+    try {
+        return await createBrowserbaseClient({
+            cwd: options.cwd,
+            globalConfigDir: options.globalConfigDir,
+        });
+    }
+    catch (error) {
+        if (error instanceof MissingApiKeyError) {
+            cliError({ command, exitCode: 2, json: flags.json, message: error.message });
+        }
+        throw error;
+    }
+}

package/dist/lib/cli-errors.d.ts

@@ -0,0 +1,19 @@
+import type { Command } from '@oclif/core';
+export type CliErrorOptions = {
+    command: Command;
+    exitCode?: number;
+    json: boolean;
+    message: string;
+    statusCode?: number | string;
+};
+/**
+ * Thrown only if `command.exit` returns without throwing (e.g. test double). JSON is already on stdout.
+ * Caught in `bin/run.js` / `bin/dev.js` so this does not surface as an unhandled rejection.
+ */
+export declare class CliJsonExitContractError extends Error {
+    constructor();
+}
+export declare function errorMessage(err: unknown): string;
+export declare function errorStatus(err: unknown): number | undefined;
+/** Print JSON or human error and exit; does not return. */
+export declare function cliError(options: CliErrorOptions): never;

package/dist/lib/cli-errors.js

@@ -0,0 +1,36 @@
+import { printErrorJson } from './json-output.js';
+/**
+ * Thrown only if `command.exit` returns without throwing (e.g. test double). JSON is already on stdout.
+ * Caught in `bin/run.js` / `bin/dev.js` so this does not surface as an unhandled rejection.
+ */
+export class CliJsonExitContractError extends Error {
+    constructor() {
+        super('zurf internal error: command.exit() returned after JSON error output; fix the test double or oclif version.');
+        this.name = 'CliJsonExitContractError';
+    }
+}
+export function errorMessage(err) {
+    if (err instanceof Error) {
+        return err.message;
+    }
+    return String(err);
+}
+export function errorStatus(err) {
+    if (err !== null &&
+        typeof err === 'object' &&
+        'status' in err &&
+        typeof err.status === 'number') {
+        return err.status;
+    }
+    return undefined;
+}
+/** Print JSON or human error and exit; does not return. */
+export function cliError(options) {
+    const { command, exitCode = 1, json, message, statusCode } = options;
+    if (json) {
+        printErrorJson(message, statusCode);
+        command.exit(exitCode);
+        throw new CliJsonExitContractError();
+    }
+    return command.error(message, { exit: exitCode });
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,34 @@
+export declare const ZURF_DIR_NAME = ".zurf";
+export declare const CONFIG_FILENAME = "config.json";
+export type ResolvedApiKey = {
+    apiKey: string;
+    path: string;
+    source: 'global';
+} | {
+    apiKey: string;
+    path: string;
+    source: 'local';
+} | {
+    apiKey: string;
+    source: 'env';
+} | {
+    source: 'none';
+};
+/** Resolved non-empty API key (excludes `none`). */
+export type ActiveApiKey = Extract<ResolvedApiKey, {
+    apiKey: string;
+}>;
+export interface ConfigFileShape {
+    apiKey?: string;
+}
+/**
+ * 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 resolveApiKey(options: {
+    cwd?: string;
+    globalConfigDir: string;
+}): ResolvedApiKey;
+export declare function writeApiKeyConfig(targetPath: string, apiKey: string): Promise<void>;

package/dist/lib/config.js

@@ -0,0 +1,66 @@
+import * as fs from 'node:fs';
+import path from 'node:path';
+export const ZURF_DIR_NAME = '.zurf';
+export const CONFIG_FILENAME = 'config.json';
+/**
+ * Path to global `config.json` under oclif's `this.config.configDir` (same rules as @oclif/core `Config.dir('config')` for `dirname` zurf).
+ */
+export function globalConfigFilePath(oclifConfigDir) {
+    return path.join(oclifConfigDir, CONFIG_FILENAME);
+}
+export function localConfigPathForCwd(cwd = process.cwd()) {
+    return path.join(path.resolve(cwd), ZURF_DIR_NAME, CONFIG_FILENAME);
+}
+export function findLocalConfigPath(startDir = process.cwd()) {
+    let dir = path.resolve(startDir);
+    const { root } = path.parse(dir);
+    while (true) {
+        const candidate = path.join(dir, ZURF_DIR_NAME, CONFIG_FILENAME);
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+        if (dir === root) {
+            break;
+        }
+        dir = path.dirname(dir);
+    }
+    return undefined;
+}
+function readApiKeyFromFile(filePath) {
+    try {
+        const raw = fs.readFileSync(filePath, 'utf8');
+        const parsed = JSON.parse(raw);
+        const key = typeof parsed.apiKey === 'string' ? parsed.apiKey.trim() : '';
+        return key.length > 0 ? key : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function resolveApiKey(options) {
+    const cwd = options.cwd ?? process.cwd();
+    const envKey = process.env.BROWSERBASE_API_KEY?.trim();
+    if (envKey) {
+        return { apiKey: envKey, source: 'env' };
+    }
+    const localPath = findLocalConfigPath(cwd);
+    if (localPath) {
+        const key = readApiKeyFromFile(localPath);
+        if (key) {
+            return { apiKey: key, path: localPath, source: 'local' };
+        }
+    }
+    const gPath = globalConfigFilePath(options.globalConfigDir);
+    const globalKey = readApiKeyFromFile(gPath);
+    if (globalKey) {
+        return { apiKey: globalKey, path: gPath, source: 'global' };
+    }
+    return { source: 'none' };
+}
+export async function writeApiKeyConfig(targetPath, apiKey) {
+    const dir = path.dirname(targetPath);
+    await fs.promises.mkdir(dir, { recursive: true });
+    const payload = { apiKey: apiKey.trim() };
+    const body = `${JSON.stringify(payload, null, 2)}\n`;
+    await fs.promises.writeFile(targetPath, body, { encoding: 'utf8', mode: 0o600 });
+}

package/dist/lib/fetch-output.d.ts

@@ -0,0 +1,20 @@
+export type FetchResponseForDisplay = {
+    content: string;
+    contentType: string;
+    encoding: string;
+    headers: Record<string, string>;
+    id: string;
+    statusCode: number;
+};
+export declare function buildFetchJsonPayload(response: FetchResponseForDisplay): {
+    content: string;
+    contentType: string;
+    encoding: string;
+    headers: Record<string, string>;
+    id: string;
+    statusCode: number;
+};
+export declare function humanFetchMetaLines(response: FetchResponseForDisplay): string[];
+/** ~8k chars keeps terminal scrollback usable while showing most HTML pages in preview. */
+export declare const HUMAN_BODY_PREVIEW_CHARS = 8000;
+export declare function truncateNote(totalChars: number): string;

package/dist/lib/fetch-output.js

@@ -0,0 +1,23 @@
+export function buildFetchJsonPayload(response) {
+    return {
+        content: response.content,
+        contentType: response.contentType,
+        encoding: response.encoding,
+        headers: response.headers,
+        id: response.id,
+        statusCode: response.statusCode,
+    };
+}
+export function humanFetchMetaLines(response) {
+    return [
+        `id: ${response.id}`,
+        `statusCode: ${response.statusCode}`,
+        `contentType: ${response.contentType}`,
+        `encoding: ${response.encoding}`,
+    ];
+}
+/** ~8k chars keeps terminal scrollback usable while showing most HTML pages in preview. */
+export const HUMAN_BODY_PREVIEW_CHARS = 8000;
+export function truncateNote(totalChars) {
+    return `… truncated (${totalChars} chars). Use --output FILE to save the full body (within the 1 MB Fetch limit).`;
+}

package/dist/lib/flags.d.ts

@@ -0,0 +1,6 @@
+/** Machine-readable output; kept separate from oclif `enableJsonFlag` so error payloads match zurf's stdout JSON contract. */
+export declare const zurfJsonFlag: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+/** Shared flags for commands that support JSON output (no `--api-key` — use BROWSERBASE_API_KEY or config files). */
+export declare const zurfBaseFlags: {
+    readonly json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+};

package/dist/lib/flags.js

@@ -0,0 +1,10 @@
+import { Flags } from '@oclif/core';
+/** Machine-readable output; kept separate from oclif `enableJsonFlag` so error payloads match zurf's stdout JSON contract. */
+export const zurfJsonFlag = Flags.boolean({
+    description: 'Print machine-readable JSON to stdout',
+    env: 'ZURF_JSON',
+});
+/** Shared flags for commands that support JSON output (no `--api-key` — use BROWSERBASE_API_KEY or config files). */
+export const zurfBaseFlags = {
+    json: zurfJsonFlag,
+};

package/dist/lib/gitignore-zurf.d.ts

@@ -0,0 +1,5 @@
+/** True if `.gitignore` content already mentions ignoring zurf's local config dir. */
+export declare function dotGitignoreMentionsZurf(content: string): boolean;
+/** Append a `.zurf/` block to `gitignorePath` when missing. No-op if already present. */
+export declare function ensureZurfGitignoreEntry(gitignorePath: string): Promise<void>;
+export declare function gitignorePathForCwd(cwd?: string): string;

package/dist/lib/gitignore-zurf.js

@@ -0,0 +1,45 @@
+import * as fs from 'node:fs/promises';
+import path from 'node:path';
+/** True if `.gitignore` content already mentions ignoring zurf's local config dir. */
+export function dotGitignoreMentionsZurf(content) {
+    for (const line of content.split(/\r?\n/)) {
+        const t = line.trim();
+        if (t === '' || t.startsWith('#')) {
+            continue;
+        }
+        if (t === '.zurf' || t === '.zurf/') {
+            return true;
+        }
+        if (t.endsWith('/.zurf') || t.endsWith('/.zurf/')) {
+            return true;
+        }
+    }
+    return false;
+}
+const BLOCK = '\n# zurf local API key\n.zurf/\n';
+/** Append a `.zurf/` block to `gitignorePath` when missing. No-op if already present. */
+export async function ensureZurfGitignoreEntry(gitignorePath) {
+    let existing = '';
+    try {
+        existing = await fs.readFile(gitignorePath, 'utf8');
+    }
+    catch (error) {
+        const code = error !== null &&
+            typeof error === 'object' &&
+            'code' in error &&
+            typeof error.code === 'string'
+            ? error.code
+            : undefined;
+        if (code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    if (dotGitignoreMentionsZurf(existing)) {
+        return;
+    }
+    const prefix = existing.length > 0 && !existing.endsWith('\n') ? '\n' : '';
+    await fs.writeFile(gitignorePath, `${existing}${prefix}${BLOCK}`, 'utf8');
+}
+export function gitignorePathForCwd(cwd = process.cwd()) {
+    return path.join(path.resolve(cwd), '.gitignore');
+}

package/dist/lib/init-input.d.ts

@@ -0,0 +1,2 @@
+export declare function readStdinIfPiped(): Promise<string | undefined>;
+export declare function promptLine(question: string): Promise<string>;