@taurgis/bonsai 1.0.5 → 1.0.6

package/dist/hooks/command-not-found/suggest.js

@@ -1,9 +1,15 @@
 import { toConfiguredId } from '@oclif/core';
 import { closestMatch } from '../../lib/text.js';
-// Nearest command must be within this edit distance to be offered as a correction. Bonsai's command
-// ids are short, so 3 catches realistic typos ("statuss", "improt") without suggesting an unrelated
-// command for input that resembles nothing.
-const MAX_SUGGESTION_DISTANCE = 3;
+import { buildEnvelope, formatErrorForJson } from '../../lib/envelope.js';
+// Nearest command must be close enough to be useful. A fixed threshold of 3 is too generous for
+// very short inputs (`wat` should not suggest `list`), while still reasonable for longer topic ids.
+function maxSuggestionDistance(input) {
+    if (input.length <= 3)
+        return 1;
+    if (input.length <= 5)
+        return 2;
+    return 3;
+}
 /**
  * The nearest visible command to a typo, plus how many leading segments of the attempted id name
  * the command. With `topicSeparator: ' '`, oclif folds every leading token of an unknown command
@@ -14,7 +20,8 @@ const MAX_SUGGESTION_DISTANCE = 3;
  */
 function findSuggestion(segments, visibleIds) {
     for (let n = segments.length; n >= 1; n--) {
-        const suggestion = closestMatch(segments.slice(0, n).join(':'), visibleIds, MAX_SUGGESTION_DISTANCE);
+        const attempted = segments.slice(0, n).join(':');
+        const suggestion = closestMatch(attempted, visibleIds, maxSuggestionDistance(attempted));
         if (suggestion)
             return { suggestion, commandSegments: n };
     }
@@ -56,6 +63,22 @@ function bareUrlInput(id) {
     }
     return DOMAIN_OR_IPV4.test(hostname) ? id : null;
 }
+function isJsonMode(argv) {
+    return argv?.includes('--json') ?? false;
+}
+function emitJsonError(command, message, code) {
+    const envelope = buildEnvelope({
+        command,
+        ok: false,
+        exitCode: 2,
+        stderr: formatErrorForJson({ message, code }),
+        data: null,
+        code,
+    });
+    process.exitCode = 2;
+    console.log(JSON.stringify(envelope, null, 2));
+    return envelope;
+}
 /**
  * Typo-aware "command not found" handler. oclif fires this before printing its own terse error;
  * throwing here (via `this.error`) replaces that default with a more helpful message. A correction
@@ -70,11 +93,14 @@ const hook = async function (opts) {
     // never finds a command for a hostname). The correction is shown, never auto-run (clig.dev).
     const bareUrl = bareUrlInput(opts.id);
     if (bareUrl) {
-        this.error([
+        const message = [
             `${bareUrl} is not a ${opts.config.bin} command.`,
             `Run ${opts.config.bin} help for a list of available commands.`,
             `Did you mean ${opts.config.bin} https://${bareUrl}? URLs need an http:// or https:// scheme.`,
-        ].join('\n'), { exit: 2 });
+        ].join('\n');
+        if (isJsonMode(opts.argv))
+            return emitJsonError(bareUrl, message, 'MISSING_URL_SCHEME');
+        this.error(message, { exit: 2 });
     }
     const segments = opts.id.split(':');
     const { suggestion, commandSegments } = findSuggestion(segments, visibleIds);
@@ -88,6 +114,9 @@ const hook = async function (opts) {
     lines.push(`Run ${opts.config.bin} help for a list of available commands.`);
     if (suggestion)
         lines.push(`Did you mean ${toConfiguredId(suggestion, opts.config)}?`);
-    this.error(lines.join('\n'), { exit: 2 });
+    const message = lines.join('\n');
+    if (isJsonMode(opts.argv))
+        return emitJsonError(attempted, message, 'COMMAND_NOT_FOUND');
+    this.error(message, { exit: 2 });
 };
 export default hook;

package/dist/lib/argv.d.ts

@@ -0,0 +1,10 @@
+export interface NormalizationResult {
+    /** The normalized argv array to set on process.argv. */
+    argv: string[];
+    /** Optional metadata indicating the shim should exit early with a JSON envelope. */
+    exitWithJson?: {
+        exitCode: number;
+        envelope: Record<string, unknown>;
+    };
+}
+export declare function normalizeArgv(rawArgv: string[]): NormalizationResult;

package/dist/lib/argv.js

@@ -0,0 +1,53 @@
+import { buildEnvelope } from './envelope.js';
+/**
+ * Normalizes process.argv (excluding Node executable and script path) so the
+ * oclif pipeline sees one consistent command structure.
+ */
+function missingUsageJsonExit() {
+    return {
+        exitCode: 2,
+        envelope: buildEnvelope({
+            command: 'bonsai',
+            ok: false,
+            exitCode: 2,
+            stderr: 'Missing URL or command. Run bonsai --help for usage.',
+            data: null,
+        }),
+    };
+}
+export function normalizeArgv(rawArgv) {
+    const onlyJsonFlags = rawArgv.length > 0 && rawArgv.every((arg) => arg === '--json');
+    if (onlyJsonFlags) {
+        return {
+            // bin/cli.mjs exits before applying argv when exitWithJson is set.
+            argv: ['--json'],
+            exitWithJson: missingUsageJsonExit(),
+        };
+    }
+    // oclif's JSON flag is command-scoped, so `bonsai list --json` works but
+    // `bonsai --json list` is otherwise parsed as an unknown command named
+    // "--json". Collect every --json, append one copy after the command/URL, and
+    // dedupe repeats like `bonsai --json --json list`.
+    const jsonMode = rawArgv.includes('--json');
+    let tokens = rawArgv.filter((arg) => arg !== '--json');
+    // clig.dev: -h and --help must always work at any level.
+    tokens = tokens.map((arg) => (arg === '-h' ? '--help' : arg));
+    if (tokens[0] === 'help') {
+        tokens = [...tokens.slice(1), '--help'];
+    }
+    const helpRequested = tokens.includes('--help');
+    let core = tokens.filter((arg) => arg !== '--help');
+    const firstArg = core[0];
+    // Treat any first arg that looks like a URL (carries a scheme) as the `fetch` shorthand.
+    // Match both `https://…` and scheme-only forms like `javascript:` or `data:` so fetch can
+    // reject unsupported protocols instead of oclif reporting a misleading "command not found".
+    const looksLikeUrl = firstArg != null && (firstArg.includes('://') || /^[a-z][a-z0-9+.-]*:/i.test(firstArg));
+    if (looksLikeUrl) {
+        core = ['fetch', ...core];
+    }
+    if (helpRequested)
+        core.push('--help');
+    if (jsonMode)
+        core.push('--json');
+    return { argv: core };
+}

package/dist/lib/envelope.d.ts

@@ -0,0 +1,36 @@
+/** Fields oclif attaches to CLIError that human pretty-print surfaces but JSON mode must mirror. */
+export interface CliErrorShape {
+    message?: string;
+    code?: string;
+    suggestions?: string[];
+    ref?: string;
+}
+/** Map oclif parse-time errors to stable Bonsai codes when the throw site did not set one. */
+export declare function stableErrorCodeFrom(err: unknown): string | undefined;
+/** Strip oclif's generic help suffix from JSON stderr — agents already have structured codes. */
+export declare function normalizeCliErrorMessage(message: string): string;
+export interface EnvelopeParts {
+    command: string;
+    ok: boolean;
+    exitCode: number;
+    stderr: string;
+    data: unknown;
+    /** Stable machine-readable error code when the failure is a CLIError with `code`. */
+    code?: string;
+    suggestions?: string[];
+    ref?: string;
+}
+/**
+ * Formats a CLI error for the JSON envelope `stderr` field — same lines as human pretty-print,
+ * without ANSI or the leading "Error:" prefix (the message is already the primary line).
+ */
+export declare function formatErrorForJson(err: CliErrorShape): string;
+/**
+ * Builds the standard Bonsai CLI JSON envelope structure.
+ * This is the single source of truth for the output envelope schema.
+ */
+export declare function buildEnvelope(parts: EnvelopeParts): Record<string, unknown>;
+/**
+ * Formats a JSON envelope to a string with indentation.
+ */
+export declare function formatEnvelope(parts: EnvelopeParts): string;

package/dist/lib/envelope.js

@@ -0,0 +1,76 @@
+/** Map oclif parse-time errors to stable Bonsai codes when the throw site did not set one. */
+export function stableErrorCodeFrom(err) {
+    const e = err;
+    if (typeof e?.code === 'string' && e.code)
+        return e.code;
+    switch (e?.constructor?.name) {
+        case 'RequiredArgsError':
+            return 'MISSING_ARGUMENT';
+        case 'FlagInvalidOptionError':
+        case 'ArgInvalidOptionError':
+            return 'INVALID_FLAG_VALUE';
+        case 'NonExistentFlagsError':
+            return 'UNKNOWN_FLAG';
+        case 'UnexpectedArgsError':
+            return 'UNEXPECTED_ARGUMENT';
+        default:
+            return undefined;
+    }
+}
+/** Strip oclif's generic help suffix from JSON stderr — agents already have structured codes. */
+export function normalizeCliErrorMessage(message) {
+    const suffix = '\nSee more help with --help';
+    return message.endsWith(suffix) ? message.slice(0, -suffix.length) : message;
+}
+/**
+ * Formats a CLI error for the JSON envelope `stderr` field — same lines as human pretty-print,
+ * without ANSI or the leading "Error:" prefix (the message is already the primary line).
+ */
+export function formatErrorForJson(err) {
+    const lines = [];
+    if (err.message)
+        lines.push(err.message);
+    if (err.code)
+        lines.push(`Code: ${err.code}`);
+    if (err.suggestions?.length) {
+        if (err.suggestions.length === 1) {
+            lines.push(`Try this: ${err.suggestions[0]}`);
+        }
+        else {
+            lines.push('Try this:');
+            for (const suggestion of err.suggestions)
+                lines.push(`* ${suggestion}`);
+        }
+    }
+    if (err.ref)
+        lines.push(`Reference: ${err.ref}`);
+    return lines.join('\n');
+}
+/**
+ * Builds the standard Bonsai CLI JSON envelope structure.
+ * This is the single source of truth for the output envelope schema.
+ */
+export function buildEnvelope(parts) {
+    const envelope = {
+        schemaVersion: 1,
+        command: parts.command,
+        ok: parts.ok,
+        exitCode: parts.exitCode,
+        stdout: '',
+        stderr: parts.stderr,
+        data: parts.data,
+    };
+    if (parts.code)
+        envelope.code = parts.code;
+    if (parts.suggestions?.length)
+        envelope.suggestions = parts.suggestions;
+    if (parts.ref)
+        envelope.ref = parts.ref;
+    return envelope;
+}
+/**
+ * Formats a JSON envelope to a string with indentation.
+ */
+export function formatEnvelope(parts) {
+    return JSON.stringify(buildEnvelope(parts), null, 2);
+}

package/dist/lib/json-meta.d.ts

@@ -0,0 +1,10 @@
+/** True when argv asks for help or version together with --json. */
+export declare function isJsonMetaRequest(argv: readonly string[]): boolean;
+/**
+ * When `--json` is combined with `--help` or `--version`, oclif would print human text to stdout.
+ * Render the same content inside the standard Bonsai JSON envelope instead.
+ */
+export declare function tryJsonMetaOutput(argv: readonly string[], root: string): Promise<{
+    exitCode: number;
+    envelope: Record<string, unknown>;
+} | null>;

package/dist/lib/json-meta.js

@@ -0,0 +1,98 @@
+import { Config, Help, toConfiguredId } from '@oclif/core';
+import { buildEnvelope } from './envelope.js';
+/** Strip ANSI color codes so JSON help text stays machine-stable. */
+function stripAnsi(text) {
+    // eslint-disable-next-line no-control-regex
+    return text.replace(/\x1b\[[0-9;]*m/g, '');
+}
+/** True when argv asks for help or version together with --json. */
+export function isJsonMetaRequest(argv) {
+    if (!argv.includes('--json'))
+        return false;
+    return argv.includes('--help') || argv.includes('--version');
+}
+class CaptureHelp extends Help {
+    lines = [];
+    log(...args) {
+        for (const line of args) {
+            // oclif emits section separators as log(''); drop empties so data.help stays compact.
+            if (line)
+                this.lines.push(line);
+        }
+    }
+}
+function helpSubject(argv) {
+    for (const arg of argv) {
+        if (arg === '--' || arg === '--help' || arg === 'help')
+            continue;
+        if (arg.startsWith('-'))
+            return;
+        return arg;
+    }
+    return undefined;
+}
+function envelopeCommandId(config, argv) {
+    const subject = helpSubject(argv);
+    if (!subject)
+        return config.bin;
+    const command = config.findCommand(subject);
+    if (command?.id)
+        return toConfiguredId(command.id, config);
+    const topic = config.findTopic(subject);
+    if (topic)
+        return topic.name;
+    return subject;
+}
+/**
+ * When `--json` is combined with `--help` or `--version`, oclif would print human text to stdout.
+ * Render the same content inside the standard Bonsai JSON envelope instead.
+ */
+export async function tryJsonMetaOutput(argv, root) {
+    if (!isJsonMetaRequest(argv))
+        return null;
+    try {
+        const config = await Config.load({ root });
+        if (argv.includes('--version')) {
+            return {
+                exitCode: 0,
+                envelope: buildEnvelope({
+                    command: config.bin,
+                    ok: true,
+                    exitCode: 0,
+                    stderr: '',
+                    data: {
+                        version: config.version,
+                        userAgent: config.userAgent,
+                    },
+                }),
+            };
+        }
+        const help = new CaptureHelp(config, config.pjson.oclif?.helpOptions ?? {});
+        await help.showHelp([...argv]);
+        const helpText = stripAnsi(help.lines.join('\n').trimEnd());
+        return {
+            exitCode: 0,
+            envelope: buildEnvelope({
+                command: envelopeCommandId(config, argv),
+                ok: true,
+                exitCode: 0,
+                stderr: '',
+                data: { help: helpText },
+            }),
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            exitCode: 1,
+            envelope: buildEnvelope({
+                command: 'bonsai',
+                ok: false,
+                exitCode: 1,
+                stderr: message,
+                data: null,
+                code: 'META_RENDER_FAILED',
+            }),
+        };
+    }
+}

package/dist/lib/research/revalidate.js

@@ -178,7 +178,9 @@ export async function revalidateCache(dataDir, existing, currentTime, options) {
                 status: 'stale',
                 artifact: existing,
                 allowed: options.allowStale,
-                error: `Revalidation failed: ${err.message}. Serving stale content within grace period.`,
+                // Carry only the underlying cause; the command layer owns the user-facing framing
+                // (so the warning reads cleanly instead of stuttering "stale … stale", "failed … failed").
+                error: err.message,
             };
         }
         throw new Error(`Revalidation failed and cache has expired beyond the grace period: ${err.message}`);

package/dist/lib/research/schema.d.ts

@@ -2,10 +2,13 @@ export interface TokenEstimate {
     compressed: number | null;
     detailed: number | null;
 }
-export type CaptureMethod = 'static_fetch' | 'browser_fallback' | 'agent_supplied' | 'route_markdown' | 'github_source';
+export declare const CAPTURE_METHODS: readonly ["static_fetch", "browser_fallback", "agent_supplied", "route_markdown", "github_source"];
+export type CaptureMethod = (typeof CAPTURE_METHODS)[number];
+export declare const ARTIFACT_TYPES: readonly ["source", "research_note", "index", "section"];
+export type ArtifactType = (typeof ARTIFACT_TYPES)[number];
 export interface ResearchArtifactMetadata {
     schema_version: number;
-    artifact_type: 'source' | 'research_note' | 'index' | 'section';
+    artifact_type: ArtifactType;
     source_url: string;
     source_urls: string[];
     normalized_url: string;

package/dist/lib/research/schema.js

@@ -1 +1,12 @@
-export {};
+// Single source of truth for the capture-method enum. Command flag `options` lists derive from this
+// so a new method can never drift out of sync with the filters that are supposed to expose it.
+export const CAPTURE_METHODS = [
+    'static_fetch',
+    'browser_fallback',
+    'agent_supplied',
+    'route_markdown',
+    'github_source',
+];
+// Single source of truth for the artifact-type enum. `index` = navigation/hub or llms.txt site
+// index; `section` = a heading-level child of a page. Command flag `options` derive from this.
+export const ARTIFACT_TYPES = ['source', 'research_note', 'index', 'section'];

package/dist/lib/text.d.ts

@@ -1,3 +1,5 @@
+/** Display label when an artifact has no topic — not a filterable topic value. */
+export declare const NO_TOPIC_LABEL = "(no topic)";
 /**
  * Pick the singular or plural noun for a count so human-readable output stays grammatical
  * ("1 entry" / "2 entries"). English has irregular plurals, so the plural is passed explicitly

package/dist/lib/text.js

@@ -1,3 +1,5 @@
+/** Display label when an artifact has no topic — not a filterable topic value. */
+export const NO_TOPIC_LABEL = '(no topic)';
 /**
  * Pick the singular or plural noun for a count so human-readable output stays grammatical
  * ("1 entry" / "2 entries"). English has irregular plurals, so the plural is passed explicitly

package/dist/sites/algolia.d.ts

@@ -0,0 +1,9 @@
+import type { SiteModule } from './types.js';
+export declare function createAlgoliaSite(id: string, name: string, domains: string[], appId: string, apiKey: string, indexName: string): SiteModule;
+export declare const react: SiteModule;
+export declare const vue: SiteModule;
+export declare const tailwind: SiteModule;
+export declare const jest: SiteModule;
+export declare const cypress: SiteModule;
+export declare const vitest: SiteModule;
+export declare const vitepress: SiteModule;

package/dist/sites/algolia.js

@@ -0,0 +1,26 @@
+import { algoliaQueryUrl, parseAlgoliaResponse } from '../lib/research/docs/remote-search.js';
+import { postJson } from '../lib/research/fetcher.js';
+export function createAlgoliaSite(id, name, domains, appId, apiKey, indexName) {
+    return {
+        id,
+        name,
+        domains,
+        search: async (query) => {
+            const url = algoliaQueryUrl({ appId, apiKey, indexName });
+            const bodyParams = { params: `query=${encodeURIComponent(query)}&hitsPerPage=20` };
+            const res = await postJson(url, bodyParams, {
+                'Content-Type': 'application/json',
+                'X-Algolia-API-Key': apiKey,
+                'X-Algolia-Application-Id': appId,
+            });
+            return parseAlgoliaResponse(res, url);
+        },
+    };
+}
+export const react = createAlgoliaSite('react', 'React', ['react.dev', 'legacy.reactjs.org'], '1FCF9AYYAT', '1b7ad4e1c89e645e351e59d40544eda1', 'beta-react');
+export const vue = createAlgoliaSite('vue', 'Vue.js', ['vuejs.org'], 'ML0LEBN7FQ', '10e7a8b13e6aec4007343338ab134e05', 'vuejs');
+export const tailwind = createAlgoliaSite('tailwind', 'Tailwind CSS', ['tailwindcss.com'], 'KNPXZI5B0M', '5fc87cef58bb80203d2207578309fab6', 'tailwindcss');
+export const jest = createAlgoliaSite('jest', 'Jest', ['jestjs.io'], 'HP439UUSOL', 'e5e670fd16f8f17caada79d6b0931682', 'jest-v2');
+export const cypress = createAlgoliaSite('cypress', 'Cypress', ['docs.cypress.io', 'cypress.io'], 'R9KDA5FMJB', 'b4af59e23bc2fa05281af7dcf13fcae5', 'cypress_docs');
+export const vitest = createAlgoliaSite('vitest', 'Vitest', ['vitest.dev'], 'ZTF29HGJ69', '9c3ced6fed60d2670bb36ab7e8bed8bc', 'vitest');
+export const vitepress = createAlgoliaSite('vitepress', 'VitePress', ['vitepress.dev'], '8J64VVRP8K', '52f578a92b88ad6abde815aae2b0ad7c', 'vitepress');

package/dist/sites/auto.d.ts

@@ -0,0 +1,8 @@
+import type { SiteModule } from './types.js';
+export declare function createAutoSite(id: string, name: string, domains: string[], docsUrl: string): SiteModule;
+export declare const angular: SiteModule;
+export declare const redux: SiteModule;
+export declare const vite: SiteModule;
+export declare const fastify: SiteModule;
+export declare const rollup: SiteModule;
+export declare const vueuse: SiteModule;

package/dist/sites/auto.js

@@ -0,0 +1,30 @@
+import { runRemoteDocsSearch } from '../lib/research/docs/remote-search-runner.js';
+import { fetchStaticHtml, fetchText, postJson } from '../lib/research/fetcher.js';
+export function createAutoSite(id, name, domains, docsUrl) {
+    return {
+        id,
+        name,
+        domains,
+        search: async (query) => {
+            const deps = {
+                fetchStatic: async (url) => {
+                    const res = await fetchStaticHtml(url);
+                    return { content: res.content, finalUrl: res.finalUrl };
+                },
+                fetchText: async (url) => {
+                    const res = await fetchText(url);
+                    return { content: res.content, status: res.status };
+                },
+                postJson: (url, body, headers) => postJson(url, body, headers),
+            };
+            const { results } = await runRemoteDocsSearch(docsUrl, query, deps);
+            return results;
+        },
+    };
+}
+export const angular = createAutoSite('angular', 'Angular', ['angular.dev'], 'https://angular.dev');
+export const redux = createAutoSite('redux', 'Redux', ['redux.js.org'], 'https://redux.js.org');
+export const vite = createAutoSite('vite', 'Vite', ['vitejs.dev', 'vite.dev'], 'https://vite.dev');
+export const fastify = createAutoSite('fastify', 'Fastify', ['fastify.dev', 'fastify.io'], 'https://fastify.dev');
+export const rollup = createAutoSite('rollup', 'Rollup', ['rollupjs.org'], 'https://rollupjs.org');
+export const vueuse = createAutoSite('vueuse', 'VueUse', ['vueuse.org'], 'https://vueuse.org');

package/dist/sites/index.js

@@ -1,11 +1,27 @@
 import { salesforce } from './salesforce/index.js';
 import { salesforceDeveloper } from './salesforce-developer/index.js';
+import { nextjs } from './nextjs/index.js';
+import { react, vue, tailwind, jest, cypress, vitest, vitepress } from './algolia.js';
+import { angular, redux, vite, fastify, rollup, vueuse } from './auto.js';
 // The known documentation sites. A plain constant, not a registry: these ship
 // with the CLI, so there is nothing to register at runtime. Sites with custom
 // fetch/search behavior live in their own module (e.g. ./salesforce). Salesforce Help and
 // Salesforce Developer are separate modules — different domains, different extraction.
 export const SITES = [
-    { id: 'react', name: 'React', domains: ['react.dev', 'legacy.reactjs.org'] },
+    react,
+    vue,
+    tailwind,
+    nextjs,
+    jest,
+    cypress,
+    vitest,
+    vitepress,
+    angular,
+    redux,
+    vite,
+    fastify,
+    rollup,
+    vueuse,
     salesforce,
     salesforceDeveloper,
     // TanStack docs embed a GitHub "edit this page" link, so capture resolves the page's source

package/dist/sites/nextjs/index.d.ts

@@ -0,0 +1,2 @@
+import type { SiteModule } from '../types.js';
+export declare const nextjs: SiteModule;

package/dist/sites/nextjs/index.js

@@ -0,0 +1,52 @@
+import { postJson } from '../../lib/research/fetcher.js';
+export const nextjs = {
+    id: 'nextjs',
+    name: 'Next.js',
+    domains: ['nextjs.org'],
+    search: async (query) => {
+        const url = 'https://nextjs.org/api/search';
+        const bodyStr = await postJson(url, { query, version: 'stable', routerType: 'app' }, {});
+        let data;
+        try {
+            // The Next.js API returns a JSON array sometimes or a JSON object with 'hits'
+            const parsed = JSON.parse(bodyStr);
+            if (Array.isArray(parsed)) {
+                data = parsed;
+            }
+            else if (parsed && Array.isArray(parsed.hits)) {
+                data = parsed.hits;
+            }
+            else {
+                throw new Error('Unexpected response format from Next.js search');
+            }
+        }
+        catch (err) {
+            throw new Error(`Failed to parse Next.js search response: ${err.message}`);
+        }
+        const queryLower = query.toLowerCase();
+        return data.map((item) => {
+            const content = item.content || '';
+            let snippet = content;
+            const idx = content.toLowerCase().indexOf(queryLower);
+            if (idx !== -1) {
+                const start = Math.max(0, idx - 40);
+                const end = Math.min(content.length, idx + 110);
+                snippet = content.slice(start, end);
+                if (start > 0)
+                    snippet = '...' + snippet;
+                if (end < content.length)
+                    snippet = snippet + '...';
+            }
+            else {
+                snippet = content.slice(0, 150);
+            }
+            // Clean up whitespace and newlines so it looks like a snippet and not a raw script
+            snippet = snippet.replace(/\s+/g, ' ').trim();
+            return {
+                url: `https://nextjs.org${item.path}${item.anchor ? `#${item.anchor}` : ''}`,
+                title: item.title ? `${item.pageTitle} - ${item.title}` : item.pageTitle || 'Untitled',
+                snippet,
+            };
+        });
+    },
+};

package/dist/sites/react/index.d.ts

@@ -0,0 +1,2 @@
+import type { SiteModule } from '../types.js';
+export declare const react: SiteModule;

package/dist/sites/react/index.js

@@ -0,0 +1,17 @@
+import { algoliaQueryUrl, parseAlgoliaResponse } from '../../lib/research/docs/remote-search.js';
+import { postJson } from '../../lib/research/fetcher.js';
+export const react = {
+    id: 'react',
+    name: 'React',
+    domains: ['react.dev', 'legacy.reactjs.org'],
+    search: async (query) => {
+        const config = {
+            appId: '1FCF9AYYAT',
+            apiKey: '1b7ad4e1c89e645e351e59d40544eda1',
+            indexName: 'beta-react'
+        };
+        const url = algoliaQueryUrl(config);
+        const body = await postJson(url, { params: `query=${encodeURIComponent(query)}` }, { 'X-Algolia-API-Key': config.apiKey, 'X-Algolia-Application-Id': config.appId });
+        return parseAlgoliaResponse(body, url);
+    }
+};

package/dist/sites/tailwind/index.d.ts

@@ -0,0 +1,2 @@
+import type { SiteModule } from '../types.js';
+export declare const tailwind: SiteModule;

package/dist/sites/tailwind/index.js

@@ -0,0 +1,17 @@
+import { algoliaQueryUrl, parseAlgoliaResponse } from '../../lib/research/docs/remote-search.js';
+import { postJson } from '../../lib/research/fetcher.js';
+export const tailwind = {
+    id: 'tailwind',
+    name: 'Tailwind CSS',
+    domains: ['tailwindcss.com'],
+    search: async (query) => {
+        const config = {
+            appId: 'KNPXZI5B0M',
+            apiKey: '5fc87cef58bb80203d2207578309fab6',
+            indexName: 'tailwindcss'
+        };
+        const url = algoliaQueryUrl(config);
+        const body = await postJson(url, { params: `query=${encodeURIComponent(query)}` }, { 'X-Algolia-API-Key': config.apiKey, 'X-Algolia-Application-Id': config.appId });
+        return parseAlgoliaResponse(body, url);
+    }
+};

package/dist/sites/vue/index.d.ts

@@ -0,0 +1,2 @@
+import type { SiteModule } from '../types.js';
+export declare const vue: SiteModule;