botdocs 0.4.0 → 0.5.0

package/dist/src/cli/server.js

@@ -0,0 +1,79 @@
+import { createServer } from 'http';
+import { promises as fs } from 'fs';
+import { join, resolve, sep, extname } from 'path';
+const MIME_TYPES = {
+    '.html': 'text/html; charset=utf-8',
+    '.css': 'text/css; charset=utf-8',
+    '.js': 'text/javascript; charset=utf-8',
+    '.mjs': 'text/javascript; charset=utf-8',
+    '.json': 'application/json; charset=utf-8',
+    '.map': 'application/json; charset=utf-8',
+    '.svg': 'image/svg+xml',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.ico': 'image/x-icon',
+    '.xml': 'application/xml; charset=utf-8',
+    '.txt': 'text/plain; charset=utf-8',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+};
+export async function startServer(rootDir, port = 0) {
+    const root = resolve(rootDir);
+    const server = createServer((req, res) => {
+        handleRequest(req, res, root).catch(() => {
+            respond(res, 500, 'text/plain; charset=utf-8', 'Internal server error');
+        });
+    });
+    return new Promise((resolveStart, rejectStart) => {
+        server.once('error', rejectStart);
+        server.listen(port, '127.0.0.1', () => {
+            const address = server.address();
+            const actualPort = typeof address === 'object' && address ? address.port : port;
+            resolveStart({
+                url: `http://127.0.0.1:${actualPort}`,
+                port: actualPort,
+                close: () => new Promise((done) => server.close(() => done())),
+            });
+        });
+    });
+}
+async function handleRequest(req, res, root) {
+    if (req.method !== 'GET' && req.method !== 'HEAD') {
+        respond(res, 405, 'text/plain; charset=utf-8', 'Method not allowed');
+        return;
+    }
+    let urlPath;
+    try {
+        urlPath = decodeURIComponent(new URL(req.url ?? '/', 'http://localhost').pathname);
+    }
+    catch {
+        respond(res, 400, 'text/plain; charset=utf-8', 'Bad request');
+        return;
+    }
+    // Complete mediation: every request resolves inside the site root or it
+    // never touches the filesystem.
+    const filePath = resolve(root, `.${sep}${urlPath}`);
+    if (filePath !== root && !filePath.startsWith(root + sep)) {
+        respond(res, 403, 'text/plain; charset=utf-8', 'Forbidden');
+        return;
+    }
+    let target = filePath;
+    try {
+        const stat = await fs.stat(target);
+        if (stat.isDirectory()) {
+            target = join(target, 'index.html');
+        }
+        const body = await fs.readFile(target);
+        respond(res, 200, MIME_TYPES[extname(target).toLowerCase()] ?? 'application/octet-stream', body);
+    }
+    catch {
+        respond(res, 404, 'text/plain; charset=utf-8', 'Not found');
+    }
+}
+function respond(res, status, contentType, body) {
+    res.writeHead(status, { 'Content-Type': contentType });
+    res.end(body);
+}

package/dist/src/cli/watcher.d.ts

@@ -0,0 +1,7 @@
+export interface WatchedChange {
+    path: string;
+}
+export interface DocWatcher {
+    close(): void;
+}
+export declare function watchDocs(inputDir: string, onChange: (changes: WatchedChange[]) => void, debounceMs?: number): DocWatcher;

package/dist/src/cli/watcher.js

@@ -0,0 +1,40 @@
+import { watch } from 'fs';
+const WATCHED_EXTENSIONS = ['.md', '.markdown'];
+const WATCHED_FILES = ['botdocs.config.json'];
+function isWatchedPath(path) {
+    if (WATCHED_EXTENSIONS.some((ext) => path.endsWith(ext)))
+        return true;
+    return WATCHED_FILES.some((file) => path === file || path.endsWith(`/${file}`));
+}
+export function watchDocs(inputDir, onChange, debounceMs = 300) {
+    let pending = new Map();
+    let timer;
+    const flush = () => {
+        timer = undefined;
+        const changes = [...pending.values()];
+        pending = new Map();
+        if (changes.length > 0) {
+            onChange(changes);
+        }
+    };
+    const schedule = (path) => {
+        pending.set(path, { path });
+        if (!timer) {
+            timer = setTimeout(flush, debounceMs);
+        }
+    };
+    const watcher = watch(inputDir, { recursive: true }, (_eventType, filename) => {
+        const path = filename ?? '';
+        // Some platforms report no filename — treat as a full rebuild trigger.
+        if (!path || isWatchedPath(path)) {
+            schedule(path);
+        }
+    });
+    return {
+        close: () => {
+            if (timer)
+                clearTimeout(timer);
+            watcher.close();
+        },
+    };
+}

package/dist/src/shared/site-root.d.ts

@@ -0,0 +1,2 @@
+export declare function rootPrefix(pageUrl: string): string;
+export declare function relativeUrl(root: string, url: string): string;

package/dist/src/shared/site-root.js

@@ -0,0 +1,9 @@
+export function rootPrefix(pageUrl) {
+    const depth = pageUrl.split('/').length - 2;
+    return depth <= 0 ? './' : '../'.repeat(depth);
+}
+export function relativeUrl(root, url) {
+    if (!url.startsWith('/') || url.startsWith('//'))
+        return url;
+    return root + (url === '/' ? 'index.html' : url.slice(1));
+}

package/dist/src/types/config.d.ts

@@ -5,6 +5,7 @@ export interface BotdocsConfig {
     theme?: Theme;
     customCss?: string;
     attribution?: boolean;
+    baseUrl?: string;
     chat?: {
         enabled?: boolean;
         welcomeMessage?: string;
@@ -12,7 +13,9 @@ export interface BotdocsConfig {
     build?: {
         chunkSize?: number;
         chunkOverlap?: number;
+        minChunkSize?: number;
         topK?: number;
+        minScore?: number;
     };
 }
 export interface BuildOptions {

package/dist/src/types/config.js

@@ -10,6 +10,8 @@ export const defaultConfig = {
     build: {
         chunkSize: 500,
         chunkOverlap: 50,
+        minChunkSize: 15,
         topK: 3,
+        minScore: 0.75,
     },
 };

package/dist/src/types/document.d.ts

@@ -3,7 +3,7 @@ export interface DocumentMetadata {
     description?: string;
     date?: string;
     author?: string;
-    [key: string]: any;
+    [key: string]: unknown;
 }
 export interface ProcessedDocument {
     filePath: string;