mdorigin 0.1.1 → 0.1.2

package/dist/index-builder.js

@@ -1,8 +1,8 @@
-import { readdir, readFile, stat, writeFile } from 'node:fs/promises';
+import { readdir, readFile, realpath, stat, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { inferDirectoryContentType } from './core/content-type.js';
 import { getDirectoryIndexCandidates } from './core/directory-index.js';
-import { parseMarkdownDocument } from './core/markdown.js';
+import { getDocumentSummary, getDocumentTitle, parseMarkdownDocument, } from './core/markdown.js';
 const INDEX_START_MARKER = '<!-- INDEX:START -->';
 const INDEX_END_MARKER = '<!-- INDEX:END -->';
 export async function buildDirectoryIndexes(options) {
@@ -73,7 +73,8 @@ export async function buildManagedIndexBlock(directoryPath) {
             continue;
         }
         const fullPath = path.join(directoryPath, entry.name);
-        if (entry.isDirectory()) {
+        const entryStats = await stat(fullPath);
+        if (entryStats.isDirectory()) {
             const resolvedEntry = await resolveDirectoryEntry(fullPath, entry.name);
             if (resolvedEntry.draft) {
                 continue;
@@ -96,7 +97,7 @@ export async function buildManagedIndexBlock(directoryPath) {
             }
             continue;
         }
-        if (!entry.isFile() || path.extname(entry.name).toLowerCase() !== '.md') {
+        if (!entryStats.isFile() || path.extname(entry.name).toLowerCase() !== '.md') {
             continue;
         }
         if (entry.name === 'index.md' || entry.name === 'README.md') {
@@ -108,9 +109,9 @@ export async function buildManagedIndexBlock(directoryPath) {
             continue;
         }
         articles.push({
-            title: parsed.meta.title ?? entry.name.slice(0, -'.md'.length),
+            title: getDocumentTitle(parsed.meta, parsed.body, entry.name.slice(0, -'.md'.length)),
             date: parsed.meta.date,
-            summary: parsed.meta.summary ?? extractFirstParagraph(parsed.body),
+            summary: getDocumentSummary(parsed.meta, parsed.body),
             link: `./${entry.name}`,
             order: parsed.meta.order,
         });
@@ -170,27 +171,55 @@ async function resolveDirectoryEntry(directoryPath, fallbackName) {
     const parsed = await parseMarkdownDocument(path.basename(indexPath), source);
     const shape = await inspectDirectoryShape(directoryPath);
     return {
-        title: parsed.meta.title ?? fallbackName,
+        title: getDocumentTitle(parsed.meta, parsed.body, fallbackName),
         type: inferDirectoryContentType(parsed.meta, shape),
         date: parsed.meta.date,
-        summary: parsed.meta.summary ?? extractFirstParagraph(parsed.body),
+        summary: getDocumentSummary(parsed.meta, parsed.body),
         draft: parsed.meta.draft === true,
         order: parsed.meta.order,
     };
 }
 async function listDirectoriesRecursively(rootDir) {
+    return listDirectoriesRecursivelyInternal(rootDir, new Set());
+}
+async function listDirectoriesRecursivelyInternal(rootDir, visitedRealDirectories) {
+    const realDirectoryPath = await realpath(rootDir);
+    if (visitedRealDirectories.has(realDirectoryPath)) {
+        return [];
+    }
+    visitedRealDirectories.add(realDirectoryPath);
     const directories = [rootDir];
     const entries = await readdir(rootDir, { withFileTypes: true });
+    const rootShape = await inspectDirectoryShape(rootDir);
     for (const entry of entries) {
-        if (!entry.isDirectory() || entry.name.startsWith('.')) {
+        if (entry.name.startsWith('.')) {
+            continue;
+        }
+        if (rootShape.hasSkillIndex && isIgnoredSkillSupportDirectory(entry.name)) {
             continue;
         }
-        directories.push(...(await listDirectoriesRecursively(path.join(rootDir, entry.name))));
+        const childPath = path.join(rootDir, entry.name);
+        const childStats = await stat(childPath);
+        if (!childStats.isDirectory()) {
+            continue;
+        }
+        directories.push(childPath);
+        const childIndexPath = await resolveDirectoryIndexFile(childPath);
+        if (childIndexPath !== null) {
+            const source = await readFile(childIndexPath, 'utf8');
+            const parsed = await parseMarkdownDocument(path.basename(childIndexPath), source);
+            const shape = await inspectDirectoryShape(childPath);
+            if (inferDirectoryContentType(parsed.meta, shape) === 'post') {
+                continue;
+            }
+        }
+        directories.push(...(await listDirectoriesRecursivelyInternal(childPath, visitedRealDirectories)).slice(1));
     }
     return directories;
 }
 async function inspectDirectoryShape(directoryPath) {
     const entries = await readdir(directoryPath, { withFileTypes: true });
+    let hasSkillIndex = false;
     let hasChildDirectories = false;
     let hasExtraMarkdownFiles = false;
     let hasAssetFiles = false;
@@ -198,16 +227,21 @@ async function inspectDirectoryShape(directoryPath) {
         if (entry.name.startsWith('.')) {
             continue;
         }
-        if (entry.isDirectory()) {
+        const fullPath = path.join(directoryPath, entry.name);
+        const entryStats = await stat(fullPath);
+        if (entryStats.isDirectory()) {
             hasChildDirectories = true;
             continue;
         }
-        if (!entry.isFile()) {
+        if (!entryStats.isFile()) {
             continue;
         }
         const extension = path.extname(entry.name).toLowerCase();
         if (extension === '.md') {
-            if (entry.name !== 'index.md' && entry.name !== 'README.md') {
+            if (entry.name === 'SKILL.md') {
+                hasSkillIndex = true;
+            }
+            else if (entry.name !== 'index.md' && entry.name !== 'README.md') {
                 hasExtraMarkdownFiles = true;
             }
             continue;
@@ -215,6 +249,7 @@ async function inspectDirectoryShape(directoryPath) {
         hasAssetFiles = true;
     }
     return {
+        hasSkillIndex,
         hasChildDirectories,
         hasExtraMarkdownFiles,
         hasAssetFiles,
@@ -262,22 +297,6 @@ function compareOptionalOrder(leftOrder, rightOrder) {
     }
     return 0;
 }
-function extractFirstParagraph(markdown) {
-    const paragraphs = markdown
-        .split(/\n\s*\n/g)
-        .map((paragraph) => paragraph.trim())
-        .filter((paragraph) => paragraph !== '');
-    for (const paragraph of paragraphs) {
-        if (paragraph.startsWith('#') ||
-            paragraph.startsWith('<!--') ||
-            paragraph.startsWith('- ') ||
-            paragraph.startsWith('* ')) {
-            continue;
-        }
-        return paragraph.replace(/\s+/g, ' ');
-    }
-    return undefined;
-}
 async function resolveDirectoryIndexFile(directoryPath) {
     for (const candidate of getDirectoryIndexCandidates('')) {
         const candidatePath = path.join(directoryPath, candidate);
@@ -287,6 +306,12 @@ async function resolveDirectoryIndexFile(directoryPath) {
     }
     return null;
 }
+function isIgnoredSkillSupportDirectory(name) {
+    return (name === 'scripts' ||
+        name === 'references' ||
+        name === 'assets' ||
+        name === 'templates');
+}
 async function pathExists(filePath) {
     try {
         await stat(filePath);

package/dist/search.d.ts

@@ -0,0 +1,59 @@
+import type { ResolvedSiteConfig } from './core/site-config.js';
+type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export interface SearchHit {
+    docId: string;
+    relativePath: string;
+    canonicalUrl?: string;
+    title?: string;
+    summary?: string;
+    metadata: Record<string, JsonValue>;
+    score: number;
+    bestMatch: {
+        chunkId: number;
+        excerpt: string;
+        headingPath: string[];
+        charStart: number;
+        charEnd: number;
+        score: number;
+    };
+}
+export interface SearchApi {
+    search(query: string, options?: {
+        topK?: number;
+        relativePathPrefix?: string;
+    }): Promise<SearchHit[]>;
+}
+export interface SearchBundleEntry {
+    path: string;
+    kind: 'text' | 'binary';
+    mediaType: string;
+    text?: string;
+    base64?: string;
+}
+export interface BuildSearchBundleOptions {
+    rootDir: string;
+    outDir: string;
+    siteConfig: ResolvedSiteConfig;
+    draftMode?: 'include' | 'exclude';
+    embeddingBackend?: 'hashing' | 'model2vec';
+    model?: string;
+}
+export interface BuildSearchBundleResult {
+    outputDir: string;
+    documentCount: number;
+    chunkCount: number;
+    vectorDimensions: number;
+}
+export interface SearchBundleOptions {
+    indexDir: string;
+    query: string;
+    topK?: number;
+    relativePathPrefix?: string;
+}
+export declare function buildSearchBundle(options: BuildSearchBundleOptions): Promise<BuildSearchBundleResult>;
+export declare function searchBundle(options: SearchBundleOptions): Promise<SearchHit[]>;
+export declare function createSearchApiFromDirectory(indexDir: string): Promise<SearchApi>;
+export declare function createSearchApiFromBundle(bundleEntries: SearchBundleEntry[]): SearchApi;
+export {};

package/dist/search.js

@@ -0,0 +1,370 @@
+import { readdir, readFile, realpath, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { inferDirectoryContentType } from './core/content-type.js';
+import { getDirectoryIndexCandidates } from './core/directory-index.js';
+import { getDocumentSummary, getDocumentTitle, parseMarkdownDocument, } from './core/markdown.js';
+export async function buildSearchBundle(options) {
+    const buildModule = await loadIndexbindBuildModule();
+    const rootDir = path.resolve(options.rootDir);
+    const documents = await collectSearchDocuments(rootDir, options.siteConfig, {
+        draftMode: options.draftMode ?? 'exclude',
+    });
+    const stats = await buildModule.buildCanonicalBundle(path.resolve(options.outDir), documents, {
+        embeddingBackend: options.embeddingBackend ?? 'model2vec',
+        model: options.model,
+        sourceRootId: path.basename(rootDir),
+        sourceRootPath: rootDir,
+    });
+    return {
+        outputDir: path.resolve(options.outDir),
+        documentCount: stats.documentCount,
+        chunkCount: stats.chunkCount,
+        vectorDimensions: stats.vectorDimensions,
+    };
+}
+export async function searchBundle(options) {
+    const webModule = await loadIndexbindWebModule();
+    const index = await webModule.openWebIndex(path.resolve(options.indexDir));
+    return rerankSearchHits(await index.search(options.query, {
+        topK: options.topK ?? 10,
+        relativePathPrefix: options.relativePathPrefix,
+    }));
+}
+export async function createSearchApiFromDirectory(indexDir) {
+    const webModule = await loadIndexbindWebModule();
+    const index = await webModule.openWebIndex(path.resolve(indexDir));
+    return {
+        async search(query, options) {
+            return rerankSearchHits(await index.search(query, {
+                topK: options?.topK,
+                relativePathPrefix: options?.relativePathPrefix,
+            }));
+        },
+    };
+}
+export function createSearchApiFromBundle(bundleEntries) {
+    let indexPromise = null;
+    return {
+        async search(query, options) {
+            if (indexPromise === null) {
+                indexPromise = openWebIndexFromBundle(bundleEntries);
+            }
+            const index = await indexPromise;
+            return rerankSearchHits(await index.search(query, {
+                topK: options?.topK,
+                relativePathPrefix: options?.relativePathPrefix,
+            }));
+        },
+    };
+}
+async function collectSearchDocuments(rootDir, siteConfig, options) {
+    const searchDocuments = await listSearchDocuments(rootDir);
+    const documents = [];
+    for (const document of searchDocuments) {
+        const markdown = await readFile(document.absolutePath, 'utf8');
+        const parsed = await parseMarkdownDocument(document.relativePath, markdown);
+        if (parsed.meta.draft === true && options.draftMode === 'exclude') {
+            continue;
+        }
+        const canonicalPath = getCanonicalHtmlPathForContentPath(document.relativePath);
+        const absoluteCanonicalUrl = siteConfig.siteUrl
+            ? new URL(trimLeadingSlash(canonicalPath), ensureTrailingSlash(siteConfig.siteUrl)).toString()
+            : canonicalPath;
+        documents.push({
+            docId: canonicalPath,
+            sourcePath: document.absolutePath,
+            relativePath: document.relativePath,
+            canonicalUrl: absoluteCanonicalUrl,
+            title: getDocumentTitle(parsed.meta, parsed.body, fallbackTitleFromRelativePath(document.relativePath)),
+            summary: getDocumentSummary(parsed.meta, parsed.body),
+            content: markdown,
+            metadata: buildSearchMetadata(document.relativePath, canonicalPath, parsed.meta, siteConfig),
+        });
+    }
+    return documents;
+}
+async function listSearchDocuments(rootDir) {
+    const results = [];
+    await walkDirectory(rootDir, '', new Set(), results);
+    results.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
+    return results;
+}
+async function walkDirectory(absoluteDirectoryPath, relativeDirectoryPath, visitedRealDirectories, results) {
+    const realDirectoryPath = await realpath(absoluteDirectoryPath);
+    if (visitedRealDirectories.has(realDirectoryPath)) {
+        return;
+    }
+    visitedRealDirectories.add(realDirectoryPath);
+    const entries = await readdir(absoluteDirectoryPath, { withFileTypes: true });
+    const shape = await inspectDirectoryShape(absoluteDirectoryPath);
+    const indexFile = await resolveVisibleDirectoryIndexFile(absoluteDirectoryPath, relativeDirectoryPath);
+    if (indexFile) {
+        results.push(indexFile);
+    }
+    for (const entry of entries) {
+        if (entry.name.startsWith('.')) {
+            continue;
+        }
+        const absoluteEntryPath = path.join(absoluteDirectoryPath, entry.name);
+        const entryStats = await stat(absoluteEntryPath);
+        const relativeEntryPath = relativeDirectoryPath === ''
+            ? entry.name
+            : path.posix.join(relativeDirectoryPath, entry.name);
+        if (entryStats.isFile()) {
+            if (path.posix.extname(entry.name).toLowerCase() !== '.md') {
+                continue;
+            }
+            if (DIRECTORY_INDEX_FILENAMES_LOWER.has(entry.name.toLowerCase())) {
+                continue;
+            }
+            results.push({
+                absolutePath: absoluteEntryPath,
+                relativePath: relativeEntryPath,
+            });
+            continue;
+        }
+        if (!entryStats.isDirectory()) {
+            continue;
+        }
+        if (shape.hasSkillIndex && isIgnoredSkillSupportDirectory(entry.name)) {
+            continue;
+        }
+        if (indexFile) {
+            const source = await readFile(indexFile.absolutePath, 'utf8');
+            const parsed = await parseMarkdownDocument(indexFile.relativePath, source);
+            if (inferDirectoryContentType(parsed.meta, shape) === 'post') {
+                continue;
+            }
+        }
+        await walkDirectory(absoluteEntryPath, relativeEntryPath, visitedRealDirectories, results);
+    }
+}
+async function resolveVisibleDirectoryIndexFile(absoluteDirectoryPath, relativeDirectoryPath) {
+    for (const candidate of getDirectoryIndexCandidates('')) {
+        const absoluteCandidatePath = path.join(absoluteDirectoryPath, candidate);
+        if (await pathExists(absoluteCandidatePath)) {
+            return {
+                absolutePath: absoluteCandidatePath,
+                relativePath: relativeDirectoryPath === ''
+                    ? candidate
+                    : path.posix.join(relativeDirectoryPath, candidate),
+            };
+        }
+    }
+    return null;
+}
+async function inspectDirectoryShape(directoryPath) {
+    const entries = await readdir(directoryPath, { withFileTypes: true });
+    let hasSkillIndex = false;
+    let hasChildDirectories = false;
+    let hasExtraMarkdownFiles = false;
+    let hasAssetFiles = false;
+    for (const entry of entries) {
+        if (entry.name.startsWith('.')) {
+            continue;
+        }
+        const absoluteEntryPath = path.join(directoryPath, entry.name);
+        const entryStats = await stat(absoluteEntryPath);
+        if (entryStats.isDirectory()) {
+            hasChildDirectories = true;
+            continue;
+        }
+        if (!entryStats.isFile()) {
+            continue;
+        }
+        const extension = path.extname(entry.name).toLowerCase();
+        if (extension === '.md') {
+            if (entry.name === 'SKILL.md') {
+                hasSkillIndex = true;
+            }
+            else if (entry.name !== 'index.md' && entry.name !== 'README.md') {
+                hasExtraMarkdownFiles = true;
+            }
+            continue;
+        }
+        hasAssetFiles = true;
+    }
+    return {
+        hasSkillIndex,
+        hasChildDirectories,
+        hasExtraMarkdownFiles,
+        hasAssetFiles,
+    };
+}
+function buildSearchMetadata(relativePath, canonicalPath, meta, siteConfig) {
+    const metadata = {
+        markdownPath: `/${relativePath}`,
+        canonicalPath,
+        siteTitle: siteConfig.siteTitle,
+    };
+    if (meta.type === 'page' || meta.type === 'post') {
+        metadata.type = meta.type;
+    }
+    if (typeof meta.date === 'string') {
+        metadata.date = meta.date;
+    }
+    if (typeof meta.order === 'number') {
+        metadata.order = meta.order;
+    }
+    if (Array.isArray(meta.aliases)) {
+        metadata.aliases = meta.aliases;
+    }
+    return metadata;
+}
+function fallbackTitleFromRelativePath(relativePath) {
+    const baseName = path.posix.basename(relativePath);
+    if (DIRECTORY_INDEX_FILENAMES_LOWER.has(baseName.toLowerCase())) {
+        return path.posix.basename(path.posix.dirname(relativePath));
+    }
+    return baseName.replace(/\.md$/i, '');
+}
+function getCanonicalHtmlPathForContentPath(contentPath) {
+    const basename = path.posix.basename(contentPath).toLowerCase();
+    if (basename === 'index.md' ||
+        basename === 'readme.md' ||
+        basename === 'skill.md') {
+        const directory = path.posix.dirname(contentPath);
+        return directory === '.' ? '/' : `/${directory}/`;
+    }
+    return `/${contentPath.slice(0, -'.md'.length)}`;
+}
+function trimLeadingSlash(value) {
+    return value.startsWith('/') ? value.slice(1) : value;
+}
+function ensureTrailingSlash(value) {
+    return value.endsWith('/') ? value : `${value}/`;
+}
+async function pathExists(filePath) {
+    try {
+        await stat(filePath);
+        return true;
+    }
+    catch (error) {
+        if (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            error.code === 'ENOENT') {
+            return false;
+        }
+        throw error;
+    }
+}
+function isIgnoredSkillSupportDirectory(name) {
+    return (name === 'scripts' ||
+        name === 'references' ||
+        name === 'assets' ||
+        name === 'templates');
+}
+async function loadIndexbindBuildModule() {
+    try {
+        return (await import('indexbind/build'));
+    }
+    catch (error) {
+        throw new Error(`Search build requires the optional package "indexbind". Install it first, for example: npm install indexbind`, { cause: error instanceof Error ? error : undefined });
+    }
+}
+async function loadIndexbindWebModule() {
+    try {
+        return (await import('indexbind/web'));
+    }
+    catch (error) {
+        throw new Error(`Search query requires the optional package "indexbind". Install it first, for example: npm install indexbind`, { cause: error instanceof Error ? error : undefined });
+    }
+}
+async function loadIndexbindCloudflareModule() {
+    try {
+        return (await import('indexbind/cloudflare'));
+    }
+    catch (error) {
+        throw new Error(`Search query requires the optional package "indexbind". Install it first, for example: npm install indexbind`, { cause: error instanceof Error ? error : undefined });
+    }
+}
+async function openWebIndexFromBundle(bundleEntries) {
+    const cloudflareModule = await loadIndexbindCloudflareModule();
+    const baseUrl = 'https://mdorigin-search.invalid/';
+    const originalFetch = globalThis.fetch;
+    const bundleMap = new Map(bundleEntries.map((entry) => [new URL(entry.path, baseUrl).toString(), entry]));
+    globalThis.fetch = async (input, init) => {
+        const requestUrl = typeof input === 'string'
+            ? input
+            : input instanceof URL
+                ? input.toString()
+                : input.url;
+        const entry = bundleMap.get(requestUrl);
+        if (entry) {
+            const headers = new Headers({ 'content-type': entry.mediaType });
+            const binaryBody = decodeBase64(entry.base64 ?? '');
+            const body = entry.kind === 'text'
+                ? entry.text ?? ''
+                : new Blob([new Uint8Array(binaryBody)], {
+                    type: entry.mediaType,
+                });
+            return new Response(body, {
+                status: 200,
+                headers,
+            });
+        }
+        return originalFetch(input, init);
+    };
+    try {
+        return await cloudflareModule.openWebIndex(new URL(baseUrl));
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+    }
+}
+function decodeBase64(value) {
+    const decoded = atob(value);
+    return Uint8Array.from(decoded, (character) => character.charCodeAt(0));
+}
+function rerankSearchHits(hits) {
+    const remaining = [...hits];
+    const ordered = [];
+    while (remaining.length > 0) {
+        let bestIndex = 0;
+        let bestScore = Number.NEGATIVE_INFINITY;
+        for (let index = 0; index < remaining.length; index += 1) {
+            const candidate = remaining[index];
+            const candidateScore = getDiversifiedSearchRankScore(candidate, ordered);
+            if (candidateScore > bestScore) {
+                bestScore = candidateScore;
+                bestIndex = index;
+                continue;
+            }
+            if (Math.abs(candidateScore - bestScore) <= 1e-9 &&
+                compareHits(candidate, remaining[bestIndex]) < 0) {
+                bestIndex = index;
+            }
+        }
+        ordered.push(remaining.splice(bestIndex, 1)[0]);
+    }
+    return ordered;
+}
+function getDiversifiedSearchRankScore(hit, selectedHits) {
+    let adjusted = hit.score;
+    const candidateSection = getTopLevelSection(hit.relativePath);
+    const sameSectionCount = selectedHits.filter((selectedHit) => getTopLevelSection(selectedHit.relativePath) === candidateSection).length;
+    if (sameSectionCount > 0) {
+        adjusted *= Math.pow(0.9, sameSectionCount);
+    }
+    if (isOverviewSearchHit(hit)) {
+        adjusted *= sameSectionCount > 0 ? 0.72 : 0.84;
+    }
+    return adjusted;
+}
+function compareHits(left, right) {
+    if (right.bestMatch.score !== left.bestMatch.score) {
+        return right.bestMatch.score - left.bestMatch.score;
+    }
+    return left.relativePath.localeCompare(right.relativePath);
+}
+function isOverviewSearchHit(hit) {
+    const baseName = path.posix.basename(hit.relativePath).toLowerCase();
+    return baseName === 'readme.md' || baseName === 'index.md';
+}
+function getTopLevelSection(relativePath) {
+    const normalized = relativePath.replaceAll('\\', '/');
+    const [firstSegment] = normalized.split('/', 1);
+    return firstSegment ?? '';
+}
+const DIRECTORY_INDEX_FILENAMES_LOWER = new Set(getDirectoryIndexCandidates('').map((name) => name.toLowerCase()));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mdorigin",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "type": "module",
   "description": "Markdown-first publishing engine with raw Markdown and HTML views.",
   "repository": {
@@ -22,6 +22,10 @@
     "mdorigin": "dist/cli/main.js"
   },
   "exports": {
+    "./search": {
+      "types": "./dist/search.d.ts",
+      "default": "./dist/search.js"
+    },
     "./cloudflare": {
       "types": "./dist/cloudflare.d.ts",
       "default": "./dist/cloudflare.js"
@@ -39,8 +43,10 @@
     "dev": "tsx src/cli/main.ts dev",
     "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.json && node -e \"const fs=require('node:fs'); const file='dist/cli/main.js'; const source=fs.readFileSync(file,'utf8'); if (!source.startsWith('#!/usr/bin/env node\\n')) fs.writeFileSync(file, '#!/usr/bin/env node\\n' + source);\"",
     "build:index": "tsx src/cli/main.ts build index",
+    "build:search": "tsx src/cli/main.ts build search",
     "build:cloudflare": "tsx src/cli/main.ts build cloudflare",
     "init:cloudflare": "tsx src/cli/main.ts init cloudflare",
+    "search": "tsx src/cli/main.ts search",
     "check": "tsc --noEmit -p tsconfig.json",
     "test": "node --test --import tsx src/*.test.ts src/**/*.test.ts",
     "prepack": "npm run build",
@@ -62,5 +68,8 @@
     "@types/node": "^24.5.2",
     "tsx": "^4.20.5",
     "typescript": "^5.9.2"
+  },
+  "optionalDependencies": {
+    "indexbind": "^0.2.1"
   }
 }