docorbit 0.1.0 → 0.1.2

package/dist/apps/cli/src/index.js

@@ -0,0 +1,376 @@
+import { runInspectCommand } from "./commands/inspect.js";
+import { runAddCommand } from "./commands/add.js";
+import { runSearchCommand } from "./commands/search.js";
+import { runContextCommand } from "./commands/context.js";
+import { runInitCommand } from "./commands/init.js";
+import { runUpdateCommand } from "./commands/update.js";
+import { runApiCommand } from "./commands/api.js";
+import { runExamplesCommand } from "./commands/examples.js";
+import { runPitfallsCommand } from "./commands/pitfalls.js";
+import { runRecipesCommand } from "./commands/recipes.js";
+import { runMcpCommand } from "./commands/mcp.js";
+import { runVerifyCommand } from "./commands/verify.js";
+import { runDiffCommand } from "./commands/diff.js";
+import { runImpactCommand } from "./commands/impact.js";
+import { runDashboardCommand } from "./commands/dashboard.js";
+import { runExportCommand } from "./commands/export.js";
+import { handleEvaluateCommand } from "./commands/evaluate.js";
+const VERSION = '0.1.1';
+function printHelp() {
+    console.log(`
+DocOrbit — The Documentation Intelligence Layer for Coding Agents
+Version: ${VERSION}
+
+USAGE:
+  docorbit <command> [options]
+
+COMMANDS:
+  init [dir]        Scan workspace, detect project dependencies, resolve docs, and write docs.lock
+  update [pkg]      Update docs.lock dependencies (selective or global refresh)
+  inspect <url>     Probe target documentation domain for canonical machine-readable sources
+  add <url>         Discover, rank, fetch, normalize, slice, and store documentation into local SQLite
+  search "<query>"  Deterministic hybrid search across sliced documentation chunks
+  context "<task>"  Pack relevant documentation context optimized for AI coding agent tasks
+  api "<query>"     Search and inspect structured API endpoints (OpenAPI / Swagger)
+  examples "<task>" Search and filter first-class code examples by language, framework, or task
+  pitfalls "<task>" Search explicit warnings, deprecations, breaking changes, and runtime restrictions
+  recipes "<goal>"  Deterministically compile evidence-grounded implementation recipes
+  verify <code/file>Verify agent code against indexed schemas and detect mismatches/deprecations
+  diff [source]     Compare documentation versions and snapshots (detect added/removed/deprecated APIs)
+  impact [source]   Analyze impact of doc changes on project workspace files
+  dashboard         Launch local zero-dependency web inspection UI and verification playground (alias: ui)
+  export [format]   Deterministically export agent guidance files (AGENTS.md, CLAUDE.md, skill.md, llms.txt, docs-map.md)
+  eval              Run empirical comparative evaluation benchmark (DocOrbit vs Context7 vs Official Docs Fetch vs Firecrawl)
+  mcp               Start agent-native Model Context Protocol (MCP) server (stdio / streamable HTTP)
+
+OPTIONS:
+  --project <dir>    Workspace root for project-aware dependency detection (default: current dir)
+  --doc-version <v>  Target documentation version filter/boost (e.g. v14, 15.0)
+  --from <v>         Base version for documentation diffing / impact analysis (e.g. v14)
+  --to <v>           Target version for documentation diffing / impact analysis (e.g. v15)
+  --library <lib>    Filter or target specific library (e.g. stripe, next)
+  --format <fmt>     Export format: agents.md, claude.md, skill.md, llms.txt, docs-map.md
+  --output <path>    Custom output file path for export command
+  --stdout           Print exported agent content directly to stdout
+  --json             Output results as structured JSON
+  --db <path>        Custom SQLite database path (default: .docorbit/docorbit.db)
+  --tokens <num>     Token budget for context packaging (default: 3000)
+  --limit <num>      Maximum search results to return (default: 10)
+  --type <type>      Filter by chunk type: prose, code, api, warning, example, mixed
+  --method <method>  Filter API endpoints by HTTP method: get, post, put, delete, patch
+  --language <lang>  Filter code examples by language: typescript, python, go, rust, bash
+  --framework <fw>   Filter code examples by framework: next, react, express, fastapi, flask
+  --kind <kind>      Filter pitfalls by kind: deprecated, removed, breaking_change, server_only, rate_limit, security
+  --stdio            Run MCP server over standard I/O (stdin/stdout) (default)
+  --port <num>       Port for HTTP server or dashboard (default: 3737 for dashboard)
+  --host <ip>        Host to bind HTTP transport / dashboard (default: 127.0.0.1)
+  --max-pages <num>  Maximum pages to crawl and ingest (default: 50)
+  --allow-localhost  Allow localhost / loopback targets (useful for local development & testing)
+  -h, --help         Show this help message
+  -v, --version      Show DocOrbit version
+
+EXAMPLES:
+  docorbit init .
+  docorbit verify "fetch('/v1/charges', { method: 'POST' })" --doc-version v14
+  docorbit diff --from v14 --to v15
+  docorbit impact --from v14 --to v15 --project .
+  docorbit mcp --stdio
+  docorbit api "create subscription" --doc-version v1
+  docorbit examples "verify webhook signature" --language typescript --framework express
+  docorbit pitfalls "server actions" --kind server_only --doc-version v14
+  docorbit recipes "Handle webhook signature verification in Next.js" --project .
+`);
+}
+export async function main(args = process.argv.slice(2)) {
+    if (args.length === 0 || args.includes('-h') || args.includes('--help')) {
+        printHelp();
+        return;
+    }
+    if (args.includes('-v') || args.includes('--version')) {
+        console.log(`DocOrbit v${VERSION}`);
+        return;
+    }
+    const command = args[0];
+    const queryArg = args[1]?.startsWith('-') ? undefined : args[1];
+    const isJson = args.includes('--json');
+    const allowLocalhost = args.includes('--allow-localhost');
+    let dbPath;
+    const dbIdx = args.indexOf('--db');
+    if (dbIdx !== -1 && args[dbIdx + 1]) {
+        dbPath = args[dbIdx + 1];
+    }
+    let projectDir;
+    const projIdx = args.indexOf('--project');
+    if (projIdx !== -1 && args[projIdx + 1]) {
+        projectDir = args[projIdx + 1];
+    }
+    let docVersion;
+    const docVerIdx = args.indexOf('--doc-version');
+    if (docVerIdx !== -1 && args[docVerIdx + 1]) {
+        docVersion = args[docVerIdx + 1];
+    }
+    let maxPages;
+    const maxPagesIdx = args.indexOf('--max-pages');
+    if (maxPagesIdx !== -1 && args[maxPagesIdx + 1]) {
+        maxPages = parseInt(args[maxPagesIdx + 1], 10);
+    }
+    let limit;
+    const limitIdx = args.indexOf('--limit');
+    if (limitIdx !== -1 && args[limitIdx + 1]) {
+        limit = parseInt(args[limitIdx + 1], 10);
+    }
+    let tokens;
+    const tokensIdx = args.indexOf('--tokens');
+    if (tokensIdx !== -1 && args[tokensIdx + 1]) {
+        tokens = parseInt(args[tokensIdx + 1], 10);
+    }
+    let chunkType;
+    const typeIdx = args.indexOf('--type');
+    if (typeIdx !== -1 && args[typeIdx + 1]) {
+        chunkType = args[typeIdx + 1];
+    }
+    let method;
+    const methodIdx = args.indexOf('--method');
+    if (methodIdx !== -1 && args[methodIdx + 1]) {
+        method = args[methodIdx + 1];
+    }
+    let language;
+    const langIdx = args.indexOf('--language');
+    if (langIdx !== -1 && args[langIdx + 1]) {
+        language = args[langIdx + 1];
+    }
+    let framework;
+    const fwIdx = args.indexOf('--framework');
+    if (fwIdx !== -1 && args[fwIdx + 1]) {
+        framework = args[fwIdx + 1];
+    }
+    let kind;
+    const kindIdx = args.indexOf('--kind');
+    if (kindIdx !== -1 && args[kindIdx + 1]) {
+        kind = args[kindIdx + 1];
+    }
+    const isStdio = args.includes('--stdio');
+    let port;
+    const portIdx = args.indexOf('--port');
+    if (portIdx !== -1 && args[portIdx + 1]) {
+        port = parseInt(args[portIdx + 1], 10);
+    }
+    let host;
+    const hostIdx = args.indexOf('--host');
+    if (hostIdx !== -1 && args[hostIdx + 1]) {
+        host = args[hostIdx + 1];
+    }
+    let fromVersion;
+    const fromIdx = args.indexOf('--from');
+    if (fromIdx !== -1 && args[fromIdx + 1]) {
+        fromVersion = args[fromIdx + 1];
+    }
+    let toVersion;
+    const toIdx = args.indexOf('--to');
+    if (toIdx !== -1 && args[toIdx + 1]) {
+        toVersion = args[toIdx + 1];
+    }
+    let library;
+    const libIdx = args.indexOf('--library');
+    if (libIdx !== -1 && args[libIdx + 1]) {
+        library = args[libIdx + 1];
+    }
+    let output;
+    const outIdx = args.indexOf('--output');
+    if (outIdx !== -1 && args[outIdx + 1]) {
+        output = args[outIdx + 1];
+    }
+    let format;
+    const fmtIdx = args.indexOf('--format');
+    if (fmtIdx !== -1 && args[fmtIdx + 1]) {
+        format = args[fmtIdx + 1];
+    }
+    let targetSource;
+    const srcIdx = args.indexOf('--source');
+    if (srcIdx !== -1 && args[srcIdx + 1]) {
+        targetSource = args[srcIdx + 1];
+    }
+    let evalSplit;
+    const splitIdx = args.indexOf('--split');
+    if (splitIdx !== -1 && args[splitIdx + 1]) {
+        evalSplit = args[splitIdx + 1];
+    }
+    let evalStrategy;
+    const stratIdx = args.indexOf('--strategy');
+    if (stratIdx !== -1 && args[stratIdx + 1]) {
+        evalStrategy = args[stratIdx + 1];
+    }
+    let evalTask;
+    const taskIdx = args.indexOf('--task');
+    if (taskIdx !== -1 && args[taskIdx + 1]) {
+        evalTask = args[taskIdx + 1];
+    }
+    const isStdout = args.includes('--stdout');
+    const noOpen = args.includes('--no-open');
+    const isVerbose = args.includes('--verbose');
+    switch (command) {
+        case 'init': {
+            const targetDir = queryArg || projectDir || '.';
+            await runInitCommand(targetDir, { json: isJson, dbPath });
+            break;
+        }
+        case 'update': {
+            const targetPkg = queryArg;
+            await runUpdateCommand(targetPkg, { json: isJson, dbPath, projectDir });
+            break;
+        }
+        case 'inspect': {
+            if (!queryArg) {
+                console.error('Error: "inspect" requires a target URL argument.');
+                printHelp();
+                process.exit(1);
+            }
+            await runInspectCommand(queryArg, { json: isJson, allowLocalhost });
+            break;
+        }
+        case 'add': {
+            if (!queryArg) {
+                console.error('Error: "add" requires a target URL argument.');
+                printHelp();
+                process.exit(1);
+            }
+            await runAddCommand(queryArg, { json: isJson, dbPath, maxPages, allowLocalhost });
+            break;
+        }
+        case 'search': {
+            if (!queryArg) {
+                console.error('Error: "search" requires a query string argument.');
+                printHelp();
+                process.exit(1);
+            }
+            await runSearchCommand(queryArg, { json: isJson, dbPath, limit, chunkType, docVersion, projectDir });
+            break;
+        }
+        case 'context': {
+            if (!queryArg) {
+                console.error('Error: "context" requires a task description argument.');
+                printHelp();
+                process.exit(1);
+            }
+            await runContextCommand(queryArg, { json: isJson, dbPath, tokens, docVersion, projectDir });
+            break;
+        }
+        case 'api': {
+            await runApiCommand(queryArg || '', { method, docVersion, projectDir, limit, json: isJson, dbPath });
+            break;
+        }
+        case 'examples': {
+            await runExamplesCommand(queryArg || '', { language, framework, docVersion, projectDir, limit, json: isJson, dbPath });
+            break;
+        }
+        case 'pitfalls': {
+            await runPitfallsCommand(queryArg || '', { kind, docVersion, projectDir, limit, json: isJson, dbPath });
+            break;
+        }
+        case 'recipes': {
+            if (!queryArg) {
+                console.error('Error: "recipes" requires an implementation goal argument.');
+                printHelp();
+                process.exit(1);
+            }
+            await runRecipesCommand(queryArg, { docVersion, projectDir, json: isJson, dbPath });
+            break;
+        }
+        case 'mcp': {
+            await runMcpCommand({
+                stdio: isStdio || !port,
+                port,
+                host,
+                dbPath,
+                projectDir,
+            });
+            break;
+        }
+        case 'verify':
+        case 'check-api': {
+            if (!queryArg) {
+                console.error('Error: "verify" requires a code snippet or file path argument.');
+                printHelp();
+                process.exit(1);
+            }
+            await runVerifyCommand(queryArg, {
+                docVersion,
+                projectDir,
+                library,
+                language,
+                json: isJson,
+                dbPath,
+            });
+            break;
+        }
+        case 'diff': {
+            await runDiffCommand(queryArg || '', {
+                from: fromVersion,
+                to: toVersion,
+                json: isJson,
+                dbPath,
+            });
+            break;
+        }
+        case 'impact': {
+            await runImpactCommand(queryArg || '', {
+                from: fromVersion,
+                to: toVersion,
+                projectDir,
+                json: isJson,
+                dbPath,
+            });
+            break;
+        }
+        case 'dashboard':
+        case 'ui': {
+            await runDashboardCommand({
+                port,
+                host,
+                projectDir,
+                dbPath,
+                noOpen,
+            });
+            break;
+        }
+        case 'export': {
+            await runExportCommand(queryArg || format, {
+                format,
+                output,
+                stdout: isStdout,
+                projectDir,
+                docVersion,
+                targetSource,
+                json: isJson,
+                dbPath,
+            });
+            break;
+        }
+        case 'eval':
+        case 'evaluate':
+        case 'benchmark': {
+            await handleEvaluateCommand({
+                split: evalSplit,
+                strategy: evalStrategy,
+                task: evalTask,
+                output,
+                json: isJson,
+                verbose: isVerbose,
+                simulation: args.includes('--simulation'),
+            });
+            break;
+        }
+        default: {
+            console.error(`Unknown command: "${command}"\n`);
+            printHelp();
+            process.exit(1);
+        }
+    }
+}
+// Direct CLI invocation
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main().catch(err => {
+        console.error('Fatal DocOrbit Error:', err);
+        process.exit(1);
+    });
+}

package/dist/packages/core/src/dashboard/server.d.ts

@@ -0,0 +1,33 @@
+import http from 'node:http';
+import type { DocOrbitRepository } from '../../../storage/src/index.ts';
+export interface DashboardServerOptions {
+    repo: DocOrbitRepository;
+    projectDir?: string;
+    dbPath?: string;
+}
+export declare class DashboardServer {
+    private repo;
+    private projectDir?;
+    private dbPath;
+    private exportService;
+    private verificationService;
+    private diffService;
+    private impactService;
+    private server;
+    constructor(options: DashboardServerOptions);
+    /**
+     * Starts the local dashboard HTTP server.
+     */
+    start(port?: number, host?: string): Promise<{
+        server: http.Server;
+        url: string;
+        port: number;
+    }>;
+    /**
+     * Stops the server gracefully.
+     */
+    stop(): Promise<void>;
+    handleRequest(req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+    private getStats;
+    private readJsonBody;
+}

package/dist/packages/core/src/dashboard/server.js

@@ -0,0 +1,267 @@
+import http from 'node:http';
+import { URL } from 'node:url';
+import { ExportService } from "../../../export/src/index.js";
+import { VerificationService, DiffService, ImpactAnalysisService, } from "../../../verification/src/index.js";
+import { renderDashboardHtml } from "./ui.js";
+export class DashboardServer {
+    repo;
+    projectDir;
+    dbPath;
+    exportService;
+    verificationService;
+    diffService;
+    impactService;
+    server = null;
+    constructor(options) {
+        this.repo = options.repo;
+        this.projectDir = options.projectDir;
+        this.dbPath = options.dbPath || '.docorbit/docorbit.db';
+        this.exportService = new ExportService(this.repo);
+        this.verificationService = new VerificationService(this.repo);
+        this.diffService = new DiffService(this.repo);
+        this.impactService = new ImpactAnalysisService(this.repo);
+    }
+    /**
+     * Starts the local dashboard HTTP server.
+     */
+    start(port = 3737, host = '127.0.0.1') {
+        return new Promise((resolve, reject) => {
+            this.server = http.createServer(async (req, res) => {
+                try {
+                    await this.handleRequest(req, res);
+                }
+                catch (err) {
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: err.message || 'Internal Server Error' }));
+                }
+            });
+            this.server.on('error', (err) => {
+                reject(err);
+            });
+            this.server.listen(port, host, () => {
+                const address = this.server.address();
+                const actualPort = address.port;
+                const url = `http://${host}:${actualPort}/`;
+                resolve({ server: this.server, url, port: actualPort });
+            });
+        });
+    }
+    /**
+     * Stops the server gracefully.
+     */
+    stop() {
+        return new Promise((resolve) => {
+            if (this.server) {
+                this.server.close(() => {
+                    this.server = null;
+                    resolve();
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    async handleRequest(req, res) {
+        const parsedUrl = new URL(req.url || '/', `http://${req.headers.host || '127.0.0.1'}`);
+        const pathname = parsedUrl.pathname;
+        const method = (req.method || 'GET').toUpperCase();
+        // CORS for local development
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+        if (method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        // Root UI
+        if (pathname === '/' || pathname === '/index.html') {
+            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end(renderDashboardHtml());
+            return;
+        }
+        // JSON REST API
+        if (pathname.startsWith('/api/')) {
+            res.setHeader('Content-Type', 'application/json; charset=utf-8');
+            if (pathname === '/api/stats' && method === 'GET') {
+                const stats = this.getStats();
+                res.writeHead(200);
+                res.end(JSON.stringify(stats));
+                return;
+            }
+            if (pathname === '/api/sources' && method === 'GET') {
+                const sources = this.repo.sources.listSources();
+                res.writeHead(200);
+                res.end(JSON.stringify(sources));
+                return;
+            }
+            if (pathname === '/api/pages' && method === 'GET') {
+                const pages = this.repo.pages.listPages(200);
+                res.writeHead(200);
+                res.end(JSON.stringify(pages));
+                return;
+            }
+            if (pathname === '/api/apis' && method === 'GET') {
+                const q = parsedUrl.searchParams.get('q') || '';
+                const apiMethod = parsedUrl.searchParams.get('method') || undefined;
+                const docVersion = parsedUrl.searchParams.get('docVersion') || undefined;
+                const apis = this.repo.apis.searchApiEndpoints(q, {
+                    method: apiMethod,
+                    docVersion,
+                    limit: 100,
+                });
+                res.writeHead(200);
+                res.end(JSON.stringify(apis));
+                return;
+            }
+            if (pathname === '/api/pitfalls' && method === 'GET') {
+                const q = parsedUrl.searchParams.get('q') || '';
+                const kind = parsedUrl.searchParams.get('kind') || undefined;
+                const docVersion = parsedUrl.searchParams.get('docVersion') || undefined;
+                const pitfalls = this.repo.pitfalls.searchPitfalls(q, {
+                    kind,
+                    docVersion,
+                    limit: 100,
+                });
+                res.writeHead(200);
+                res.end(JSON.stringify(pitfalls));
+                return;
+            }
+            if (pathname === '/api/examples' && method === 'GET') {
+                const q = parsedUrl.searchParams.get('q') || '';
+                const language = parsedUrl.searchParams.get('language') || undefined;
+                const framework = parsedUrl.searchParams.get('framework') || undefined;
+                const docVersion = parsedUrl.searchParams.get('docVersion') || undefined;
+                const examples = this.repo.examples.searchIndexedExamples(q, {
+                    language,
+                    framework,
+                    docVersion,
+                    limit: 50,
+                });
+                res.writeHead(200);
+                res.end(JSON.stringify(examples));
+                return;
+            }
+            if (pathname === '/api/docs-map' && method === 'GET') {
+                const sourceId = parsedUrl.searchParams.get('sourceId') || undefined;
+                const docVersion = parsedUrl.searchParams.get('docVersion') || undefined;
+                const map = this.exportService.getDocumentationMap({ sourceId, docVersion });
+                res.writeHead(200);
+                res.end(JSON.stringify(map));
+                return;
+            }
+            if (pathname === '/api/export' && method === 'GET') {
+                const format = (parsedUrl.searchParams.get('format') || 'agents.md');
+                const docVersion = parsedUrl.searchParams.get('docVersion') || undefined;
+                const exp = await this.exportService.generateExport({
+                    format,
+                    docVersion,
+                    projectDir: this.projectDir,
+                });
+                res.writeHead(200);
+                res.end(JSON.stringify(exp));
+                return;
+            }
+            if (pathname === '/api/verify' && method === 'POST') {
+                const body = await this.readJsonBody(req);
+                const code = body.code || '';
+                const version = body.version || body.docVersion;
+                const library = body.library;
+                const language = body.language;
+                const verifyResult = this.verificationService.verifyCode({
+                    code,
+                    version,
+                    library,
+                    language,
+                    projectDir: this.projectDir,
+                });
+                res.writeHead(200);
+                res.end(JSON.stringify(verifyResult));
+                return;
+            }
+            if (pathname === '/api/diff' && method === 'GET') {
+                const from = parsedUrl.searchParams.get('from') || undefined;
+                const to = parsedUrl.searchParams.get('to') || undefined;
+                const source = parsedUrl.searchParams.get('source') || undefined;
+                const diffResult = this.diffService.diff({ from, to, source });
+                res.writeHead(200);
+                res.end(JSON.stringify(diffResult));
+                return;
+            }
+            if (pathname === '/api/impact' && method === 'GET') {
+                const from = parsedUrl.searchParams.get('from') || undefined;
+                const to = parsedUrl.searchParams.get('to') || undefined;
+                const targetDir = parsedUrl.searchParams.get('projectDir') || this.projectDir || process.cwd();
+                const impactResult = this.impactService.analyzeWorkspaceImpact({
+                    from,
+                    to,
+                    projectDir: targetDir,
+                });
+                res.writeHead(200);
+                res.end(JSON.stringify(impactResult));
+                return;
+            }
+            res.writeHead(404);
+            res.end(JSON.stringify({ error: `Route not found: ${pathname}` }));
+            return;
+        }
+        res.writeHead(404, { 'Content-Type': 'text/plain' });
+        res.end('Not Found');
+    }
+    getStats() {
+        const sources = this.repo.sources.listSources();
+        const totalPages = this.repo.pages.countPages();
+        const totalChunks = this.repo.chunks.countChunks();
+        let totalApis = 0;
+        let totalPitfalls = 0;
+        let totalExamples = 0;
+        const activeVersions = new Set();
+        try {
+            const raw = this.repo.db.getRawDb();
+            const apiRow = raw.prepare('SELECT COUNT(*) as c FROM api_endpoints').get();
+            totalApis = apiRow?.c || 0;
+            const pitRow = raw.prepare('SELECT COUNT(*) as c FROM pitfalls').get();
+            totalPitfalls = pitRow?.c || 0;
+            const exRow = raw.prepare('SELECT COUNT(*) as c FROM indexed_examples').get();
+            totalExamples = exRow?.c || 0;
+            const verRows = raw.prepare('SELECT DISTINCT doc_version FROM snapshots WHERE doc_version IS NOT NULL').all();
+            for (const r of verRows) {
+                if (r.doc_version)
+                    activeVersions.add(r.doc_version);
+            }
+        }
+        catch {
+            // Best-effort stats aggregation
+        }
+        return {
+            totalSources: sources.length,
+            totalPages,
+            totalChunks,
+            totalApis,
+            totalPitfalls,
+            totalExamples,
+            totalRecipes: 5,
+            activeVersions: Array.from(activeVersions).sort(),
+            dbPath: this.dbPath,
+            untrusted: true,
+        };
+    }
+    readJsonBody(req) {
+        return new Promise((resolve, reject) => {
+            let body = '';
+            req.on('data', (chunk) => {
+                body += chunk.toString();
+            });
+            req.on('end', () => {
+                try {
+                    resolve(body ? JSON.parse(body) : {});
+                }
+                catch (err) {
+                    reject(new Error('Invalid JSON payload'));
+                }
+            });
+            req.on('error', (err) => reject(err));
+        });
+    }
+}

package/dist/packages/core/src/dashboard/ui.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Embedded HTML/CSS/JS dashboard UI for DocOrbit.
+ * Lightweight, zero external dependencies, zero CDN requests, fully offline capable.
+ */
+export declare function renderDashboardHtml(): string;

package/{packages/core/src/dashboard/ui.ts → dist/packages/core/src/dashboard/ui.js}

@@ -2,8 +2,8 @@
  * Embedded HTML/CSS/JS dashboard UI for DocOrbit.
  * Lightweight, zero external dependencies, zero CDN requests, fully offline capable.
  */
-export function renderDashboardHtml(): string {
-  return `<!DOCTYPE html>
+export function renderDashboardHtml() {
+    return `<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="UTF-8">