docorbit 0.1.0 → 0.1.1

package/dist/apps/cli/src/formatters/retrieval.d.ts

@@ -0,0 +1,3 @@
+import type { SearchResult, ContextPackage } from '../../../../packages/shared/src/index.ts';
+export declare function formatSearchResults(query: string, results: SearchResult[]): string;
+export declare function formatContextPackage(pkg: ContextPackage): string;

package/dist/apps/cli/src/formatters/retrieval.js

@@ -0,0 +1,61 @@
+import { RESET, BOLD, DIM, GREEN, CYAN, YELLOW, MAGENTA } from "./colors.js";
+export function formatSearchResults(query, results) {
+    const lines = [];
+    lines.push('');
+    lines.push(`${BOLD}${CYAN}DocOrbit${RESET} ${DIM}— Search Results for: "${query}"${RESET}`);
+    lines.push(`${DIM}${'═'.repeat(64)}${RESET}`);
+    if (results.length === 0) {
+        lines.push(`  ${YELLOW}No matching documentation chunks found.${RESET}`);
+        lines.push(`${DIM}${'═'.repeat(64)}${RESET}`);
+        lines.push('');
+        return lines.join('\n');
+    }
+    for (let i = 0; i < results.length; i++) {
+        const res = results[i];
+        const chunk = res.chunk;
+        const breadcrumb = chunk.sectionPath.length > 0 ? chunk.sectionPath.join(' > ') : (chunk.title || 'General');
+        lines.push(`  ${BOLD}${i + 1}.${RESET} ${CYAN}${breadcrumb}${RESET} ${GREEN}(Score: ${res.score})${RESET}`);
+        lines.push(`     ${DIM}Type: ${chunk.chunkType} | Est. Tokens: ~${chunk.tokenEstimate} | Chunk: ${chunk.id}${RESET}`);
+        if (res.matchReasons.length > 0) {
+            lines.push(`     ${DIM}Matches: ${res.matchReasons.join(' • ')}${RESET}`);
+        }
+        if (res.symbols.length > 0) {
+            lines.push(`     ${MAGENTA}Symbols: ${res.symbols.map(s => s.name).join(', ')}${RESET}`);
+        }
+        const preview = chunk.content.split('\n').filter(l => l.trim().length > 0).slice(0, 3).join('\n     ');
+        lines.push(`     ${DIM}│${RESET} ${preview}`);
+        lines.push('');
+    }
+    lines.push(`${DIM}${'═'.repeat(64)}${RESET}`);
+    lines.push('');
+    return lines.join('\n');
+}
+export function formatContextPackage(pkg) {
+    const lines = [];
+    lines.push('');
+    lines.push(`${BOLD}${GREEN}DocOrbit${RESET} ${DIM}— Assembled Context Package${RESET}`);
+    lines.push(`${DIM}${'═'.repeat(64)}${RESET}`);
+    lines.push(`${BOLD}Task:${RESET}             ${CYAN}${pkg.task}${RESET}`);
+    lines.push(`${BOLD}Detected Intent:${RESET}  ${MAGENTA}${pkg.detectedIntent}${RESET}`);
+    lines.push(`${BOLD}Estimated Tokens:${RESET} ~${pkg.totalEstimatedTokens} / ${pkg.tokenBudget} (heuristic)`);
+    lines.push(`${BOLD}Chunks Included:${RESET}  ${pkg.chunks.length}`);
+    lines.push(`${BOLD}Sources Cited:${RESET}    ${pkg.sources.length > 0 ? pkg.sources.join(', ') : 'Local documentation'}`);
+    if (pkg.warnings.length > 0) {
+        lines.push('');
+        lines.push(`${YELLOW}${BOLD}Advisories & Warnings (${pkg.warnings.length}):${RESET}`);
+        for (const w of pkg.warnings) {
+            lines.push(`  ${YELLOW}⚠ ${w}${RESET}`);
+        }
+    }
+    lines.push('');
+    lines.push(`${BOLD}Package Markdown Preview:${RESET}`);
+    lines.push(`${DIM}${'─'.repeat(64)}${RESET}`);
+    const previewLines = pkg.markdown.split('\n').slice(0, 20);
+    lines.push(previewLines.join('\n'));
+    if (pkg.markdown.split('\n').length > 20) {
+        lines.push(`\n${DIM}... (${pkg.markdown.split('\n').length - 20} more lines in full package)${RESET}`);
+    }
+    lines.push(`${DIM}${'═'.repeat(64)}${RESET}`);
+    lines.push('');
+    return lines.join('\n');
+}

package/{apps/cli/src/formatters/terminal.ts → dist/apps/cli/src/formatters/terminal.d.ts}

@@ -3,4 +3,3 @@ export * from './inspection.ts';
 export * from './retrieval.ts';
 export * from './knowledge.ts';
 export * from './verification.ts';
-

package/dist/apps/cli/src/formatters/terminal.js

@@ -0,0 +1,5 @@
+export * from "./colors.js";
+export * from "./inspection.js";
+export * from "./retrieval.js";
+export * from "./knowledge.js";
+export * from "./verification.js";

package/dist/apps/cli/src/formatters/verification.d.ts

@@ -0,0 +1,4 @@
+import type { DocDiffResult, ImpactAnalysisResult, VerificationResult } from '../../../../packages/shared/src/index.ts';
+export declare function formatVerificationReport(result: VerificationResult): string;
+export declare function formatDiffReport(diff: DocDiffResult): string;
+export declare function formatImpactReport(impact: ImpactAnalysisResult): string;

package/dist/apps/cli/src/formatters/verification.js

@@ -0,0 +1,102 @@
+import { RESET, BOLD, DIM, GREEN, CYAN, YELLOW, RED } from "./colors.js";
+export function formatVerificationReport(result) {
+    const lines = [];
+    const verdictColor = result.verdict === 'verified'
+        ? GREEN
+        : result.verdict === 'warning'
+            ? YELLOW
+            : result.verdict === 'mismatch'
+                ? RED
+                : CYAN;
+    lines.push(`${BOLD}${CYAN}DocOrbit — Code & Schema Verification${RESET}`);
+    lines.push(`Verdict: ${verdictColor}${BOLD}${result.verdict.toUpperCase()}${RESET}`);
+    lines.push(`Summary: ${result.summary}`);
+    if (result.targetVersion) {
+        lines.push(`Target Version:  ${YELLOW}${result.targetVersion}${RESET}`);
+    }
+    if (result.projectVersion) {
+        lines.push(`Project Version: ${YELLOW}${result.projectVersion}${RESET}`);
+    }
+    lines.push(`Total Checks:    ${result.totalChecks}\n`);
+    if (result.findings.length === 0) {
+        lines.push(`${GREEN}✔ No schema mismatches, deprecations, or syntax issues detected.${RESET}`);
+        return lines.join('\n');
+    }
+    lines.push(`${BOLD}Findings (${result.findings.length}):${RESET}`);
+    for (const f of result.findings) {
+        const fColor = f.severity === 'error' ? RED : f.severity === 'warning' ? YELLOW : CYAN;
+        const loc = f.location?.line ? ` (Line ${f.location.line})` : '';
+        lines.push(`  ${fColor}• [${f.rule.toUpperCase()}]${loc}: ${f.message}${RESET}`);
+        if (f.location?.snippet) {
+            lines.push(`    ${DIM}${f.location.snippet}${RESET}`);
+        }
+        if (f.expected) {
+            lines.push(`    ${DIM}Expected: ${String(f.expected)}${RESET}`);
+        }
+        if (f.actual) {
+            lines.push(`    ${DIM}Actual:   ${String(f.actual)}${RESET}`);
+        }
+    }
+    return lines.join('\n');
+}
+export function formatDiffReport(diff) {
+    const lines = [];
+    const from = diff.fromVersion || diff.fromSnapshotId || 'previous';
+    const to = diff.toVersion || diff.toSnapshotId || 'latest';
+    lines.push(`${BOLD}${CYAN}DocOrbit — Documentation & API Diff${RESET}`);
+    lines.push(`Comparing: ${YELLOW}${from}${RESET} ➔ ${YELLOW}${to}${RESET}`);
+    lines.push(`Endpoints: +${diff.summary.endpointsAdded} added, -${diff.summary.endpointsRemoved} removed, ~${diff.summary.endpointsModified} modified, !${diff.summary.endpointsDeprecated} deprecated`);
+    lines.push(`Pitfalls:  +${diff.summary.pitfallsAdded} added, -${diff.summary.pitfallsRemoved} removed\n`);
+    if (diff.apiChanges.length > 0) {
+        lines.push(`${BOLD}API Endpoint Changes:${RESET}`);
+        for (const ep of diff.apiChanges) {
+            const badge = ep.changeType === 'added'
+                ? `${GREEN}[ADDED]${RESET}`
+                : ep.changeType === 'removed'
+                    ? `${RED}[REMOVED]${RESET}`
+                    : ep.changeType === 'deprecated'
+                        ? `${YELLOW}[DEPRECATED]${RESET}`
+                        : `${CYAN}[MODIFIED]${RESET}`;
+            lines.push(`  ${badge} ${ep.method.toUpperCase()} ${ep.path}`);
+            if (ep.changes) {
+                for (const ch of ep.changes) {
+                    lines.push(`    ${DIM}• ${ch}${RESET}`);
+                }
+            }
+        }
+        lines.push('');
+    }
+    if (diff.pitfallChanges.length > 0) {
+        lines.push(`${BOLD}Pitfall Changes:${RESET}`);
+        for (const p of diff.pitfallChanges) {
+            const badge = p.changeType === 'added' ? `${YELLOW}[NEW WARNING]${RESET}` : `${DIM}[REMOVED]${RESET}`;
+            lines.push(`  ${badge} ${p.pitfall.kind}: ${p.pitfall.title}`);
+        }
+    }
+    return lines.join('\n');
+}
+export function formatImpactReport(impact) {
+    const lines = [];
+    lines.push(`${BOLD}${CYAN}DocOrbit — Project Impact Analysis${RESET}`);
+    lines.push(`Workspace:      ${impact.projectDir}`);
+    lines.push(`Files Scanned:  ${impact.totalFilesScanned}`);
+    lines.push(`Impacted Files: ${impact.affectedFilesCount}`);
+    lines.push(`Total Matches:  ${impact.affectedLocations.length}\n`);
+    if (impact.affectedLocations.length === 0) {
+        lines.push(`${GREEN}✔ Zero project files impacted by documentation/API changes.${RESET}`);
+        return lines.join('\n');
+    }
+    lines.push(`${BOLD}Impacted Locations:${RESET}`);
+    for (const loc of impact.affectedLocations) {
+        const cert = loc.certainty === 'high'
+            ? `${RED}[HIGH]${RESET}`
+            : loc.certainty === 'medium'
+                ? `${YELLOW}[MED]${RESET}`
+                : `${DIM}[HEUR]${RESET}`;
+        lines.push(`  ${cert} ${BOLD}${loc.filePath}:${loc.line}${RESET}`);
+        lines.push(`    ${YELLOW}Reason:  ${loc.reason}${RESET}`);
+        lines.push(`    ${DIM}Pattern: ${loc.matchedPattern}${RESET}`);
+        lines.push(`    ${DIM}Snippet: ${loc.snippet}${RESET}\n`);
+    }
+    return lines.join('\n');
+}

package/dist/apps/cli/src/index.d.ts

@@ -0,0 +1 @@
+export declare function main(args?: string[]): Promise<void>;

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;
+}