docorbit 0.1.0 → 0.1.2

package/dist/packages/workspace/src/resolver.js

@@ -0,0 +1,164 @@
+import { readDocsLock } from "./lockfile.js";
+import { detectWorkspaceDependencies } from "./detector.js";
+import { resolveDocVersion } from "./semver.js";
+/**
+ * Normalizes query string for token matching against dependency names.
+ */
+function normalizeQueryTokens(query) {
+    const tokens = query
+        .toLowerCase()
+        .replace(/[^\w\s-]/g, ' ')
+        .split(/\s+/)
+        .filter(t => t.length > 1);
+    const set = new Set(tokens);
+    // Add common aliases
+    if (set.has('nextjs') || set.has('next.js')) {
+        set.add('next');
+    }
+    if (set.has('reactjs') || set.has('react.js')) {
+        set.add('react');
+    }
+    if (set.has('vuejs') || set.has('vue.js')) {
+        set.add('vue');
+    }
+    return set;
+}
+/**
+ * Resolves project context and detects if a query targets a specific dependency in the project.
+ * Uses docs.lock if present for zero-overhead deterministic pinned resolution,
+ * or falls back to live manifest scanning and resolution.
+ */
+export function resolveProjectContext(projectDir, query, repo) {
+    const lock = readDocsLock(projectDir);
+    const queryTokens = normalizeQueryTokens(query);
+    if (lock) {
+        // 1. Check locked dependencies
+        for (const [key, lockedDoc] of Object.entries(lock.dependencies)) {
+            const cleanName = lockedDoc.name.toLowerCase().replace(/^@[^/]+\//, '');
+            const parts = cleanName.split(/[-_.]/);
+            const matches = queryTokens.has(lockedDoc.name.toLowerCase()) ||
+                queryTokens.has(cleanName) ||
+                parts.some(p => p.length > 2 && queryTokens.has(p));
+            if (matches) {
+                return {
+                    projectDir,
+                    hasLockfile: true,
+                    matchedDependency: {
+                        name: lockedDoc.name,
+                        projectVersion: lockedDoc.resolvedDependencyVersion,
+                        targetDocVersion: lockedDoc.docVersion,
+                        targetSnapshotId: lockedDoc.snapshotId,
+                        confidence: lockedDoc.confidence,
+                        matchType: lockedDoc.matchType,
+                    },
+                    allDependencies: Object.values(lock.dependencies).map(d => ({
+                        name: d.name,
+                        ecosystem: d.ecosystem,
+                        requestedVersion: d.requestedVersion,
+                        resolvedVersion: d.resolvedDependencyVersion,
+                        sourceFile: d.sourceFile,
+                    })),
+                };
+            }
+        }
+        return {
+            projectDir,
+            hasLockfile: true,
+            allDependencies: Object.values(lock.dependencies).map(d => ({
+                name: d.name,
+                ecosystem: d.ecosystem,
+                requestedVersion: d.requestedVersion,
+                resolvedVersion: d.resolvedDependencyVersion,
+                sourceFile: d.sourceFile,
+            })),
+        };
+    }
+    // 2. Fallback: scan workspace manifests directly
+    const scan = detectWorkspaceDependencies(projectDir);
+    const allSnapshots = repo.listSnapshots();
+    const allSources = repo.listSources();
+    for (const dep of scan.dependencies) {
+        const cleanName = dep.name.toLowerCase().replace(/^@[^/]+\//, '');
+        const parts = cleanName.split(/[-_.]/);
+        const matches = queryTokens.has(dep.name.toLowerCase()) ||
+            queryTokens.has(cleanName) ||
+            parts.some(p => p.length > 2 && queryTokens.has(p));
+        if (matches) {
+            // Find matching source
+            const src = allSources.find(s => {
+                const u = s.url.toLowerCase();
+                return u.includes(cleanName) || u.includes(dep.name.toLowerCase());
+            });
+            if (src) {
+                const snapshots = allSnapshots.filter(s => s.sourceId === src.id);
+                const availableVersions = snapshots.map(s => s.docVersion || 'latest');
+                const projectVer = dep.resolvedVersion || dep.requestedVersion;
+                const resolution = resolveDocVersion(projectVer, availableVersions, dep.name);
+                const chosenSnapshot = snapshots.find(s => (s.docVersion || 'latest') === resolution.selectedDocVersion) || snapshots[0];
+                return {
+                    projectDir,
+                    hasLockfile: false,
+                    matchedDependency: {
+                        name: dep.name,
+                        projectVersion: projectVer,
+                        targetDocVersion: resolution.selectedDocVersion,
+                        targetSnapshotId: chosenSnapshot?.id,
+                        confidence: resolution.confidence,
+                        matchType: resolution.matchType,
+                    },
+                    allDependencies: scan.dependencies,
+                };
+            }
+        }
+    }
+    return {
+        projectDir,
+        hasLockfile: false,
+        allDependencies: scan.dependencies,
+    };
+}
+export class WorkspaceResolver {
+    repo;
+    constructor(repo) {
+        this.repo = repo;
+    }
+    resolveProjectContext(projectDir, query) {
+        return resolveProjectContext(projectDir, query, this.repo);
+    }
+    scanWorkspace(projectDir) {
+        return detectWorkspaceDependencies(projectDir);
+    }
+    resolveWorkspace(scan, _existingLock) {
+        const allSnapshots = this.repo.listSnapshots();
+        const allSources = this.repo.listSources();
+        const matches = [];
+        for (const dep of scan.dependencies) {
+            const cleanName = dep.name.toLowerCase().replace(/^@[^/]+\//, '');
+            const src = allSources.find(s => {
+                const u = s.url.toLowerCase();
+                return u.includes(cleanName) || u.includes(dep.name.toLowerCase()) ||
+                    (s.metadata && String(s.metadata.name || '').toLowerCase() === cleanName);
+            });
+            if (!src)
+                continue;
+            const snapshots = allSnapshots.filter(s => s.sourceId === src.id);
+            if (snapshots.length === 0)
+                continue;
+            const availableVersions = snapshots.map(s => s.docVersion || 'latest');
+            const projectVer = dep.resolvedVersion || dep.requestedVersion;
+            const resolution = resolveDocVersion(projectVer, availableVersions, dep.name);
+            const chosenSnapshot = snapshots.find(s => (s.docVersion || 'latest') === resolution.selectedDocVersion) || snapshots[0];
+            matches.push({
+                dependency: dep,
+                targetVersion: resolution.selectedDocVersion,
+                confidence: resolution.confidence,
+                snapshotId: chosenSnapshot?.id,
+                matchedBy: resolution.matchType,
+            });
+        }
+        return { matches };
+    }
+    resolveVersion(projectVersion, availableDocVersions, packageName) {
+        return resolveDocVersion(projectVersion, availableDocVersions, packageName);
+    }
+}

package/dist/packages/workspace/src/semver.d.ts

@@ -0,0 +1,33 @@
+import type { VersionResolutionResult } from '../../shared/src/index.ts';
+export interface ParsedSemVer {
+    major: number;
+    minor: number;
+    patch: number;
+    prerelease?: string;
+    raw: string;
+}
+/**
+ * Parses a version string into semantic components.
+ * Handles standard SemVer, leading 'v', partial versions ('14', '14.2'),
+ * and prereleases ('15.0.0-rc.1', '14.2.0-canary').
+ */
+export declare function parseSemVer(versionStr: string): ParsedSemVer | null;
+/**
+ * Deterministic SemVer comparison.
+ * Returns negative if v1 < v2, positive if v1 > v2, 0 if v1 == v2.
+ * Prereleases have lower precedence than normal releases (e.g. 15.0.0-rc.1 < 15.0.0).
+ */
+export declare function compareVersions(v1: string, v2: string): number;
+/**
+ * Evaluates whether a concrete version satisfies a SemVer range specification.
+ * Supports '^', '~', '>=', '<=', '<', '>', '*', 'x', space-separated and '||'.
+ */
+export declare function satisfiesRange(version: string, range: string): boolean;
+/**
+ * Deterministically resolves a project's dependency version to the best available
+ * documentation version using the hierarchical confidence ladder:
+ * exact (1.0) -> major_minor (0.95) -> major (0.90) -> range (0.85) -> latest_fallback (0.50) -> unresolved (0.0)
+ *
+ * Never claims exact match when documentation is coarse (e.g. 'v14' or 'latest').
+ */
+export declare function resolveDocVersion(projectVersion: string, availableDocVersions: string[], dependencyName?: string): VersionResolutionResult;

package/dist/packages/workspace/src/semver.js

@@ -0,0 +1,235 @@
+/**
+ * Parses a version string into semantic components.
+ * Handles standard SemVer, leading 'v', partial versions ('14', '14.2'),
+ * and prereleases ('15.0.0-rc.1', '14.2.0-canary').
+ */
+export function parseSemVer(versionStr) {
+    if (!versionStr || typeof versionStr !== 'string')
+        return null;
+    const cleaned = versionStr.trim().replace(/^[v=]/, '');
+    // Match major, optional minor, optional patch, optional prerelease
+    const match = cleaned.match(/^(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:-([0-9A-Za-z.-]+))?/);
+    if (!match)
+        return null;
+    const major = parseInt(match[1], 10);
+    const minor = match[2] !== undefined ? parseInt(match[2], 10) : 0;
+    const patch = match[3] !== undefined ? parseInt(match[3], 10) : 0;
+    const prerelease = match[4];
+    return { major, minor, patch, prerelease, raw: versionStr.trim() };
+}
+/**
+ * Deterministic SemVer comparison.
+ * Returns negative if v1 < v2, positive if v1 > v2, 0 if v1 == v2.
+ * Prereleases have lower precedence than normal releases (e.g. 15.0.0-rc.1 < 15.0.0).
+ */
+export function compareVersions(v1, v2) {
+    const p1 = parseSemVer(v1);
+    const p2 = parseSemVer(v2);
+    if (!p1 && !p2)
+        return v1.localeCompare(v2);
+    if (!p1)
+        return -1;
+    if (!p2)
+        return 1;
+    if (p1.major !== p2.major)
+        return p1.major - p2.major;
+    if (p1.minor !== p2.minor)
+        return p1.minor - p2.minor;
+    if (p1.patch !== p2.patch)
+        return p1.patch - p2.patch;
+    // Prerelease comparison:
+    // 1.0.0-alpha < 1.0.0 (version with prerelease is lower than version without)
+    if (p1.prerelease && !p2.prerelease)
+        return -1;
+    if (!p1.prerelease && p2.prerelease)
+        return 1;
+    if (p1.prerelease && p2.prerelease) {
+        return p1.prerelease.localeCompare(p2.prerelease);
+    }
+    return 0;
+}
+/**
+ * Evaluates whether a concrete version satisfies a SemVer range specification.
+ * Supports '^', '~', '>=', '<=', '<', '>', '*', 'x', space-separated and '||'.
+ */
+export function satisfiesRange(version, range) {
+    if (!range || range === '*' || range === 'latest' || range === 'x') {
+        return true;
+    }
+    const ver = parseSemVer(version);
+    if (!ver)
+        return false;
+    // Handle disjunction (||)
+    if (range.includes('||')) {
+        return range.split('||').some(r => satisfiesRange(version, r.trim()));
+    }
+    // Handle conjunction (space separated conditions e.g. ">=14.0.0 <15.0.0")
+    const clauses = range.trim().split(/\s+/).filter(Boolean);
+    if (clauses.length > 1) {
+        return clauses.every(c => satisfiesRange(version, c));
+    }
+    const single = clauses[0];
+    // Caret ranges: ^14.2.0 -> >=14.2.0 <15.0.0 (or for 0.x: ^0.2.3 -> >=0.2.3 <0.3.0)
+    if (single.startsWith('^')) {
+        const base = parseSemVer(single.slice(1));
+        if (!base)
+            return false;
+        if (ver.major !== base.major)
+            return false;
+        if (base.major === 0) {
+            if (ver.minor !== base.minor)
+                return false;
+            return ver.patch >= base.patch;
+        }
+        if (ver.minor < base.minor)
+            return false;
+        if (ver.minor === base.minor && ver.patch < base.patch)
+            return false;
+        return true;
+    }
+    // Tilde ranges: ~14.2.0 -> >=14.2.0 <14.3.0
+    if (single.startsWith('~')) {
+        const base = parseSemVer(single.slice(1));
+        if (!base)
+            return false;
+        if (ver.major !== base.major || ver.minor !== base.minor)
+            return false;
+        return ver.patch >= base.patch;
+    }
+    // Wildcard ranges: 14.x or 14.*
+    const wildcardMatch = single.match(/^(\d+)(?:\.(\d+|\*|x))?(?:\.(\d+|\*|x))?$/);
+    if (wildcardMatch) {
+        const wMajor = parseInt(wildcardMatch[1], 10);
+        const wMinor = wildcardMatch[2];
+        if (ver.major !== wMajor)
+            return false;
+        if (wMinor && wMinor !== '*' && wMinor !== 'x') {
+            if (ver.minor !== parseInt(wMinor, 10))
+                return false;
+        }
+        return true;
+    }
+    // Comparison operators: >=, <=, >, <, =
+    const compMatch = single.match(/^(>=|<=|>|<|=)(.+)$/);
+    if (compMatch) {
+        const op = compMatch[1];
+        const target = compMatch[2].trim();
+        const cmp = compareVersions(version, target);
+        if (op === '>=')
+            return cmp >= 0;
+        if (op === '<=')
+            return cmp <= 0;
+        if (op === '>')
+            return cmp > 0;
+        if (op === '<')
+            return cmp < 0;
+        if (op === '=')
+            return cmp === 0;
+    }
+    // Direct equality check
+    const targetVer = parseSemVer(single);
+    if (targetVer) {
+        return (ver.major === targetVer.major &&
+            ver.minor === targetVer.minor &&
+            ver.patch === targetVer.patch);
+    }
+    return false;
+}
+/**
+ * Deterministically resolves a project's dependency version to the best available
+ * documentation version using the hierarchical confidence ladder:
+ * exact (1.0) -> major_minor (0.95) -> major (0.90) -> range (0.85) -> latest_fallback (0.50) -> unresolved (0.0)
+ *
+ * Never claims exact match when documentation is coarse (e.g. 'v14' or 'latest').
+ */
+export function resolveDocVersion(projectVersion, availableDocVersions, dependencyName = 'package') {
+    if (!availableDocVersions || availableDocVersions.length === 0) {
+        return {
+            dependencyName,
+            projectVersion,
+            selectedDocVersion: 'unresolved',
+            matchType: 'unresolved',
+            confidence: 0.0,
+            availableVersions: [],
+        };
+    }
+    const cleaned = projectVersion.replace(/^[\^~=v><\s]+/, '');
+    const pVer = parseSemVer(projectVersion) || parseSemVer(cleaned);
+    const cleanTarget = projectVersion.replace(/^[v=]/, '');
+    // 1. Exact match (e.g. project '14.2.3' and doc '14.2.3' or 'v14.2.3')
+    const exactMatch = availableDocVersions.find(v => {
+        const c = v.replace(/^[v=]/, '');
+        return c === cleanTarget;
+    });
+    if (exactMatch) {
+        return {
+            dependencyName,
+            projectVersion,
+            selectedDocVersion: exactMatch,
+            matchType: 'exact',
+            confidence: 1.0,
+            availableVersions: availableDocVersions,
+        };
+    }
+    if (pVer) {
+        // 2. Major.Minor match (e.g. project '14.2.3' and doc 'v14.2' or '14.2')
+        const mmTarget = `${pVer.major}.${pVer.minor}`;
+        const mmMatch = availableDocVersions.find(v => {
+            const c = v.replace(/^[v=]/, '');
+            return c === mmTarget || c === `${mmTarget}.x`;
+        });
+        if (mmMatch) {
+            return {
+                dependencyName,
+                projectVersion,
+                selectedDocVersion: mmMatch,
+                matchType: 'major_minor',
+                confidence: 0.95,
+                availableVersions: availableDocVersions,
+            };
+        }
+        // 3. Major match (e.g. project '14.2.3' and doc 'v14', '14.x', or '14')
+        const majorTarget = `${pVer.major}`;
+        const majorMatch = availableDocVersions.find(v => {
+            const c = v.replace(/^[v=]/, '');
+            return c === majorTarget || c === `${majorTarget}.x` || c === `${majorTarget}.*`;
+        });
+        if (majorMatch) {
+            return {
+                dependencyName,
+                projectVersion,
+                selectedDocVersion: majorMatch,
+                matchType: 'major',
+                confidence: 0.90,
+                availableVersions: availableDocVersions,
+            };
+        }
+        // 4. SemVer range satisfaction (find doc version that satisfies project version range or vice versa)
+        const rangeMatch = availableDocVersions
+            .filter(v => !['latest', 'stable', 'current', 'main', 'default'].includes(v.toLowerCase()))
+            .find(v => {
+            return satisfiesRange(projectVersion, v) || satisfiesRange(v, projectVersion);
+        });
+        if (rangeMatch) {
+            return {
+                dependencyName,
+                projectVersion,
+                selectedDocVersion: rangeMatch,
+                matchType: 'range',
+                confidence: 0.85,
+                availableVersions: availableDocVersions,
+            };
+        }
+    }
+    // 5. Fallback: 'latest' / 'stable' / 'current' or highest available version
+    const latestCandidate = availableDocVersions.find(v => ['latest', 'stable', 'current', 'main', 'default'].includes(v.toLowerCase()));
+    const fallbackVersion = latestCandidate || availableDocVersions[0];
+    return {
+        dependencyName,
+        projectVersion,
+        selectedDocVersion: fallbackVersion,
+        matchType: 'latest_fallback',
+        confidence: 0.50,
+        availableVersions: availableDocVersions,
+    };
+}

package/package.json

@@ -1,28 +1,29 @@
 {
   "name": "docorbit",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "The Documentation Intelligence Layer for AI Coding Agents",
   "type": "module",
-  "main": "packages/core/src/index.ts",
+  "main": "./dist/packages/core/src/index.js",
+  "types": "./dist/packages/core/src/index.d.ts",
   "bin": {
     "docorbit": "./bin/docorbit.js"
   },
   "files": [
     "bin",
-    "apps",
-    "packages",
+    "dist",
     "README.md",
     "LICENSE"
   ],
   "engines": {
-    "node": ">=22.6.0"
+    "node": ">=22.5.0"
   },
   "scripts": {
+    "build": "tsc",
+    "prepack": "npm run build && npm test",
     "test": "node --experimental-strip-types --test tests/unit/*.test.ts tests/integration/*.test.ts",
     "test:unit": "node --experimental-strip-types --test tests/unit/*.test.ts",
     "test:integration": "node --experimental-strip-types --test tests/integration/*.test.ts",
-    "docorbit": "node --experimental-strip-types bin/docorbit.js",
-    "prepack": "npm test"
+    "docorbit": "node bin/docorbit.js"
   },
   "repository": {
     "type": "git",
@@ -42,5 +43,8 @@
     "context"
   ],
   "author": "DocOrbit Team",
-  "license": "MIT"
-}
+  "license": "MIT",
+  "dependencies": {
+    "docorbit": "^0.1.1"
+  }
+}

package/apps/cli/bin/docorbit.js

@@ -1,8 +0,0 @@
-#!/usr/bin/env -S node --experimental-strip-types
-
-import { main } from '../src/index.ts';
-
-main().catch(err => {
-  console.error('Fatal DocOrbit Error:', err);
-  process.exit(1);
-});

package/apps/cli/src/commands/add.ts

@@ -1,44 +0,0 @@
-import { DocOrbitDb, DocOrbitRepository } from '../../../../packages/storage/src/index.ts';
-import { IngestionPipeline } from '../../../../packages/core/src/index.ts';
-import { formatIngestionResult } from '../formatters/terminal.ts';
-
-export interface AddCommandOptions {
-  json?: boolean;
-  dbPath?: string;
-  maxPages?: number;
-  allowLocalhost?: boolean;
-}
-
-export async function runAddCommand(targetUrl: string, options: AddCommandOptions = {}): Promise<void> {
-  if (!targetUrl) {
-    console.error('Error: Please provide a documentation target URL.');
-    console.error('Usage: docorbit add <url> [--json] [--db <path>]');
-    process.exit(1);
-  }
-
-  const dbPath = options.dbPath || '.docorbit/docorbit.db';
-  const db = new DocOrbitDb(dbPath);
-  const repository = new DocOrbitRepository(db);
-
-  try {
-    const pipeline = new IngestionPipeline(repository, {
-      allowLocalhostForTesting: options.allowLocalhost,
-      crawlerConfig: {
-        maxPages: options.maxPages || 50,
-      },
-    });
-
-    const result = await pipeline.ingest(targetUrl);
-
-    if (options.json) {
-      console.log(JSON.stringify(result, null, 2));
-    } else {
-      console.log(formatIngestionResult(result));
-    }
-  } catch (err: unknown) {
-    console.error(`DocOrbit Ingestion Error: ${err instanceof Error ? err.message : String(err)}`);
-    process.exit(1);
-  } finally {
-    db.close();
-  }
-}

package/apps/cli/src/commands/api.ts

@@ -1,38 +0,0 @@
-import { DocOrbitDb, DocOrbitRepository } from '../../../../packages/storage/src/index.ts';
-import { resolveProjectContext } from '../../../../packages/workspace/src/index.ts';
-import type { ApiCommandOptions } from '../../../../packages/shared/src/index.ts';
-import { formatApiEndpoints } from '../formatters/terminal.ts';
-
-export async function runApiCommand(query: string = '', options: ApiCommandOptions = {}): Promise<void> {
-  const dbPath = options.dbPath || '.docorbit/docorbit.db';
-  const db = new DocOrbitDb(dbPath);
-  const repository = new DocOrbitRepository(db);
-
-  try {
-    let effectiveDocVersion = options.docVersion;
-
-    if (options.projectDir) {
-      const projContext = resolveProjectContext(options.projectDir, query, repository);
-      if (projContext.matchedDependency && !effectiveDocVersion) {
-        effectiveDocVersion = projContext.matchedDependency.targetDocVersion;
-      }
-    }
-
-    const endpoints = repository.searchApiEndpoints(query, {
-      method: options.method,
-      docVersion: effectiveDocVersion,
-      limit: options.limit || 20,
-    });
-
-    if (options.json) {
-      console.log(JSON.stringify(endpoints, null, 2));
-    } else {
-      console.log(formatApiEndpoints(endpoints, query));
-    }
-  } catch (err: unknown) {
-    console.error(`DocOrbit API Error: ${err instanceof Error ? err.message : String(err)}`);
-    process.exit(1);
-  } finally {
-    db.close();
-  }
-}

package/apps/cli/src/commands/context.ts

@@ -1,47 +0,0 @@
-import { DocOrbitDb, DocOrbitRepository } from '../../../../packages/storage/src/index.ts';
-import { RetrievalEngine } from '../../../../packages/retrieval/src/index.ts';
-import { formatContextPackage } from '../formatters/terminal.ts';
-
-export interface ContextCommandOptions {
-  json?: boolean;
-  dbPath?: string;
-  tokens?: number;
-  maxChunks?: number;
-  snapshotId?: string;
-  docVersion?: string;
-  projectDir?: string;
-}
-
-export async function runContextCommand(task: string, options: ContextCommandOptions = {}): Promise<void> {
-  if (!task) {
-    console.error('Error: Please provide a coding task description.');
-    console.error('Usage: docorbit context "<task>" [--tokens <n>] [--doc-version <ver>] [--project <dir>] [--json] [--db <path>]');
-    process.exit(1);
-  }
-
-  const dbPath = options.dbPath || '.docorbit/docorbit.db';
-  const db = new DocOrbitDb(dbPath);
-  const repository = new DocOrbitRepository(db);
-  const engine = new RetrievalEngine(repository);
-
-  try {
-    const pkg = await engine.buildContext(task, {
-      tokenBudget: options.tokens || 3000,
-      maxChunks: options.maxChunks,
-      snapshotId: options.snapshotId,
-      docVersion: options.docVersion,
-      projectDir: options.projectDir,
-    });
-
-    if (options.json) {
-      console.log(JSON.stringify(pkg, null, 2));
-    } else {
-      console.log(formatContextPackage(pkg));
-    }
-  } catch (err: unknown) {
-    console.error(`DocOrbit Context Error: ${err instanceof Error ? err.message : String(err)}`);
-    process.exit(1);
-  } finally {
-    db.close();
-  }
-}

package/apps/cli/src/commands/dashboard.ts

@@ -1,55 +0,0 @@
-import path from 'node:path';
-import { DocOrbitDb, DocOrbitRepository } from '../../../../packages/storage/src/index.ts';
-import { DashboardServer } from '../../../../packages/core/src/index.ts';
-import { c } from '../formatters/colors.ts';
-
-export interface DashboardCommandOptions {
-  port?: number;
-  host?: string;
-  projectDir?: string;
-  dbPath?: string;
-  noOpen?: boolean;
-}
-
-export async function runDashboardCommand(options: DashboardCommandOptions = {}): Promise<void> {
-  const projectDir = options.projectDir ? path.resolve(options.projectDir) : process.cwd();
-  const dbPath = options.dbPath || path.join(projectDir, '.docorbit', 'docorbit.db');
-  const port = options.port || 3737;
-  const host = options.host || '127.0.0.1';
-
-  const db = new DocOrbitDb(dbPath);
-  const repo = new DocOrbitRepository(db);
-
-  const server = new DashboardServer({
-    repo,
-    projectDir,
-    dbPath,
-  });
-
-  try {
-    const info = await server.start(port, host);
-    console.log(`\n${c.bold(c.cyan('DocOrbit Local Dashboard'))}`);
-    console.log(`${c.dim('Documentation Intelligence & Verification Layer')}\n`);
-    console.log(`  ${c.green('●')} Server running at: ${c.bold(c.underline(info.url))}`);
-    console.log(`  ${c.dim('Database:')} ${dbPath}`);
-    console.log(`  ${c.dim('Workspace:')} ${projectDir}`);
-    console.log(`  ${c.dim('Security:')} ${c.yellow('untrusted documentation boundary enforced')}\n`);
-    console.log(c.dim('Press Ctrl+C to stop.\n'));
-
-    // Keep process alive until interrupted
-    await new Promise<void>((resolve) => {
-      const shutdown = async () => {
-        console.log(`\n${c.dim('Stopping dashboard server...')}`);
-        await server.stop();
-        db.close();
-        resolve();
-      };
-      process.on('SIGINT', shutdown);
-      process.on('SIGTERM', shutdown);
-    });
-  } catch (err: any) {
-    db.close();
-    console.error(c.red(`Failed to start dashboard server: ${err.message}`));
-    process.exit(1);
-  }
-}