codesearch-mcp 0.0.17-alpha.1 → 0.0.18-alpha

package/dist/src/services/SearcherService.js

@@ -39,7 +39,13 @@ const path = __importStar(require("path"));
 const readline = __importStar(require("readline"));
 const child_process_1 = require("child_process");
 const file_utils_1 = require("../file-utils");
-const LoggerService_1 = require("./LoggerService");
+const MonorepoAwareDiscoveryService_1 = require("./MonorepoAwareDiscoveryService");
+const SILENT_LOGGER = {
+    debug() { },
+    info() { },
+    warn() { },
+    error() { },
+};
 const EMPTY_META = { description: null, stack: null, notes: null, relations: null };
 const GREP_MAX_RESULTS = 200;
 const GREP_RAW_LIMIT = GREP_MAX_RESULTS * 5;
@@ -49,14 +55,78 @@ const FIND_SYMBOL_RAW_LIMIT = FIND_SYMBOL_LIMIT * 10;
 class SearcherService {
     db;
     embedder;
+    discovery;
     config;
     logger;
-    constructor(db, embedder, config, logger = LoggerService_1.LoggerService.silent()) {
+    constructor(db, embedder, discovery, config, logger = SILENT_LOGGER) {
         this.db = db;
         this.embedder = embedder;
+        this.discovery = discovery;
         this.config = config;
         this.logger = logger;
     }
+    /** Lazily-built, cached map of project name → real filesystem root. */
+    rootMap;
+    /** Cached, lazily-built map of leaf project name → real filesystem root (via discovery). */
+    projectRootMap() {
+        if (!this.rootMap) {
+            this.rootMap = new Map((0, MonorepoAwareDiscoveryService_1.toLeafProjects)(this.discovery.discover(this.config.workspaceRoot)).map(p => [p.name, p.path]));
+        }
+        return this.rootMap;
+    }
+    /**
+     * Resolve a project name to its real filesystem root. Uses discovery (leaf
+     * projects) so nested-monorepo names like `repo/app` map to their true path;
+     * falls back to `join(workspaceRoot, name)` when the name is unknown (e.g. a
+     * project since removed from disk, or a flat project not surfaced by discovery).
+     */
+    resolveProjectRoot(name) {
+        let root = this.projectRootMap().get(name);
+        if (root === undefined) {
+            // Cache miss — the project may have been added/renamed on disk since the
+            // map was built (mcp/web servers are long-lived). Rebuild once and retry
+            // before the flat fallback, which is wrong for nested-monorepo names
+            // (`repo/app` lives at `repo/apps/app`, not `repo/app`).
+            this.rootMap = undefined;
+            root = this.projectRootMap().get(name);
+        }
+        return root ?? path.join(this.config.workspaceRoot, name);
+    }
+    /**
+     * Project-level dependency edges aggregated from `code_dependency`: an edge
+     * `A → B` means some file in project A imports a file owned by project B.
+     * Used by the graph to draw links between a monorepo's sub-projects. Only
+     * edges whose target file belongs to an indexed project are returned (targets
+     * outside any indexed project — e.g. unindexed libs — are skipped).
+     */
+    async getProjectEdges() {
+        const rows = await this.db.query(`SELECT DISTINCT project, "toFile" FROM code_dependency`);
+        // Reverse map: workspace-relative project root → name, longest first so the
+        // most specific owner wins (e.g. repo/apps/account before repo).
+        const byRelPath = [...this.projectRootMap().entries()]
+            .map(([name, abs]) => ({ name, rel: path.relative(this.config.workspaceRoot, abs) }))
+            .sort((a, b) => b.rel.length - a.rel.length);
+        const ownerOf = (toFile) => {
+            for (const { name, rel } of byRelPath) {
+                if (toFile === rel || toFile.startsWith(rel + path.sep) || toFile.startsWith(rel + '/'))
+                    return name;
+            }
+            return null;
+        };
+        const seen = new Set();
+        const edges = [];
+        for (const { project, toFile } of rows) {
+            const to = ownerOf(toFile);
+            if (!to || to === project)
+                continue;
+            const key = project + ' ' + to;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            edges.push({ from: project, to });
+        }
+        return edges;
+    }
     async prepareQuery(raw) {
         const t0 = Date.now();
         if (this.config.search.autoTranslate && this.isNonEnglish(raw) && this.embedder.translate) {
@@ -73,8 +143,9 @@ class SearcherService {
        GROUP BY "serviceName"
        ORDER BY "serviceName"`);
         return rows.map(r => {
-            const meta = (0, file_utils_1.readRagMeta)(path.join(this.config.workspaceRoot, r.serviceName));
-            return { ...r, ...(typeof meta === 'object' ? meta : EMPTY_META) };
+            const projectRoot = this.resolveProjectRoot(r.serviceName);
+            const meta = (0, file_utils_1.readRagMeta)(projectRoot);
+            return { ...r, path: projectRoot, ...(typeof meta === 'object' ? meta : EMPTY_META) };
         });
     }
     async searchChunks(query, limit, project, threshold) {
@@ -115,7 +186,7 @@ class SearcherService {
         }
         catch (err) {
             this.logger.warn('SearcherService: rerank failed, falling back to vector order', {
-                reason: err.message,
+                reason: err instanceof Error ? err.message : String(err),
                 ms: Date.now() - t0,
             });
             return candidates.slice(0, limit);
@@ -168,6 +239,8 @@ class SearcherService {
         if (pairs.length === 0)
             return new Map();
         const n = pairs.length;
+        // Use proportional limit: 50 imports + 50 usedBy per file
+        const proportionalLimit = Math.max(2000, n * 100);
         const firstHalf = pairs.map((_, i) => `($${i * 2 + 1}::text, $${i * 2 + 2}::text)`).join(', ');
         const secondHalf = pairs.map((_, i) => `($${n * 2 + i * 2 + 1}::text, $${n * 2 + i * 2 + 2}::text)`).join(', ');
         const params = [
@@ -184,7 +257,7 @@ class SearcherService {
          FROM (VALUES ${secondHalf}) AS r(fp, proj)
          JOIN code_dependency d ON d."toFile" = r.fp AND d.project = r.proj
 
-         LIMIT 2000`, params);
+         LIMIT ${proportionalLimit}`, params);
         const ctx = new Map();
         for (const { filePath } of pairs)
             ctx.set(filePath, { imports: new Set(), usedBy: new Set() });
@@ -227,7 +300,7 @@ class SearcherService {
          FROM code_dependency
          WHERE "fromFile" = $1 AND project = $2
 
-         UNION
+         UNION ALL
 
          SELECT d."toFile", deps.depth + 1, deps."toFile" AS via
          FROM code_dependency d
@@ -270,7 +343,7 @@ class SearcherService {
          FROM code_dependency
          WHERE "toFile" = $1 AND project = $2
 
-         UNION
+         UNION ALL
 
          SELECT d."fromFile", rdeps.depth + 1, rdeps."fromFile" AS via
          FROM code_dependency d
@@ -308,25 +381,23 @@ class SearcherService {
         this.logger.debug('SearcherService: getCallers result', { count: rows.length, ms: Date.now() - t0 });
         return rows;
     }
-    grepSymbol(symbol, project, excludeFile) {
+    async grepSymbol(symbol, project, excludeFile) {
         const t0 = Date.now();
         this.logger.debug('SearcherService: grepSymbol', { symbol, project, excludeFile });
-        const projectDir = path.join(this.config.workspaceRoot, project);
-        const result = (0, child_process_1.spawnSync)('grep', [
+        const projectDir = this.resolveProjectRoot(project);
+        const result = await this.spawnGrep([
             '-rn', '-F', '-w',
             '-m', String(GREP_RAW_LIMIT),
             '--include=*.ts', '--include=*.tsx', '--include=*.js', '--include=*.jsx',
             ...GREP_EXCLUDE_DIRS,
             symbol,
             projectDir,
-        ], { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
-        if (result.error || !result.stdout) {
-            if (result.error)
-                this.logger.error('SearcherService: grep failed', { method: 'grepSymbol', reason: result.error.message });
+        ]);
+        if (!result) {
             return { matches: [], truncated: false };
         }
         const excludeAbsPath = path.join(this.config.workspaceRoot, excludeFile);
-        const all = result.stdout.split('\n').flatMap(line => {
+        const all = result.split('\n').flatMap(line => {
             const match = line.match(/^(.+?):(\d+):/);
             if (!match)
                 return [];
@@ -345,7 +416,7 @@ class SearcherService {
         if (!/^[\w$]+$/.test(name))
             throw new Error('Invalid symbol name');
         if (kind === 'method')
-            return Promise.resolve(this.grepFindSymbol(name, project, kind));
+            return this.grepFindSymbol(name, project, kind);
         return this.findSymbolFromIndex(name, project, kind);
     }
     async findSymbolFromIndex(name, project, kind) {
@@ -385,29 +456,25 @@ class SearcherService {
             return this.grepFindSymbol(name, project, kind);
         }
     }
-    grepFindSymbol(name, project, kind) {
+    async grepFindSymbol(name, project, kind) {
         const t0 = Date.now();
         this.logger.debug('SearcherService: findSymbol', { name, project, kind, source: 'grep' });
         const searchDir = project
-            ? path.join(this.config.workspaceRoot, project)
+            ? this.resolveProjectRoot(project)
             : this.config.workspaceRoot;
         const pattern = this.buildFindSymbolPattern(name, kind);
-        const result = (0, child_process_1.spawnSync)('grep', [
+        const result = await this.spawnGrep([
             '-rn', '-E',
             '-m', String(FIND_SYMBOL_RAW_LIMIT),
             '--include=*.ts', '--include=*.tsx', '--include=*.js', '--include=*.jsx',
             ...GREP_EXCLUDE_DIRS,
             pattern,
             searchDir,
-        ], { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
-        if (result.error) {
-            this.logger.error('SearcherService: grep failed', { method: 'findSymbol', reason: result.error.message });
-            return { hits: [], truncated: false };
-        }
-        if (!result.stdout)
+        ]);
+        if (!result)
             return { hits: [], truncated: false };
         const hits = [];
-        for (const raw of result.stdout.split('\n')) {
+        for (const raw of result.split('\n')) {
             if (hits.length >= FIND_SYMBOL_LIMIT)
                 break;
             const m = raw.match(/^(.+?):(\d+):(.*)$/);
@@ -434,7 +501,7 @@ class SearcherService {
     listFiles(relativePath, project, depth, pattern) {
         const t0 = Date.now();
         this.logger.debug('SearcherService: listFiles', { relativePath, project, depth, pattern });
-        const projectRoot = path.join(this.config.workspaceRoot, project);
+        const projectRoot = this.resolveProjectRoot(project);
         const resolvedTarget = path.resolve(projectRoot, relativePath);
         const resolvedProject = path.resolve(projectRoot);
         if (resolvedTarget !== resolvedProject && !resolvedTarget.startsWith(resolvedProject + path.sep)) {
@@ -512,24 +579,33 @@ class SearcherService {
         let lineNo = 0;
         let lastRead = 0;
         let hasMore = false;
-        for await (const line of rl) {
-            lineNo++;
-            if (lineNo >= startLine && lineNo <= endLine)
-                lines.push(line);
-            if (lineNo <= endLine)
-                lastRead = lineNo;
-            if (lineNo > endLine) {
-                hasMore = true;
-                rl.close();
-                stream.destroy();
-                break;
+        try {
+            for await (const line of rl) {
+                lineNo++;
+                if (lineNo >= startLine && lineNo <= endLine)
+                    lines.push(line);
+                if (lineNo <= endLine)
+                    lastRead = lineNo;
+                if (lineNo > endLine) {
+                    hasMore = true;
+                    rl.close();
+                    stream.destroy();
+                    break;
+                }
             }
         }
+        catch (err) {
+            rl.close();
+            stream.destroy();
+            throw err;
+        }
         this.logger.debug('SearcherService: readFileRange result', { linesRead: lines.length, hasMore, ms: Date.now() - t0 });
         return { ok: true, filePath, startLine, endLine: Math.min(endLine, lastRead), lines, hasMore };
     }
     isNonEnglish(text) {
-        return /[^\x00-\x7F]/.test(text);
+        // Use Unicode script detection: check for CJK, Cyrillic, Arabic, Hebrew, Thai, etc.
+        // Excludes common non-ASCII punctuation (smart quotes, em-dashes, accented Latin chars)
+        return /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Cyrillic}\p{Script=Arabic}\p{Script=Hebrew}\p{Script=Thai}\p{Script=Devanagari}]/u.test(text);
     }
     walkDir(absDir, currentDepth, maxDepth, pattern, lines) {
         let entries;
@@ -590,5 +666,40 @@ class SearcherService {
             return 'method';
         return 'variable';
     }
+    /**
+     * Async wrapper around grep to avoid blocking the event loop.
+     * Returns stdout as a string, or null if grep returned no results or errored.
+     */
+    spawnGrep(args) {
+        return new Promise((resolve) => {
+            const proc = (0, child_process_1.spawn)('grep', args, { stdio: ['ignore', 'pipe', 'pipe'] });
+            const chunks = [];
+            let totalBytes = 0;
+            const MAX_BUFFER = 10 * 1024 * 1024;
+            proc.stdout.on('data', (chunk) => {
+                totalBytes += chunk.length;
+                if (totalBytes <= MAX_BUFFER) {
+                    chunks.push(chunk);
+                }
+            });
+            proc.stderr.on('data', () => { });
+            proc.on('error', (err) => {
+                this.logger.error('SearcherService: grep spawn failed', { reason: err.message });
+                resolve(null);
+            });
+            proc.on('close', (code) => {
+                // grep returns 1 for "no matches" — not an error
+                if (code !== 0 && code !== 1) {
+                    this.logger.warn('SearcherService: grep exited with code', { code });
+                }
+                if (chunks.length === 0) {
+                    resolve(null);
+                }
+                else {
+                    resolve(Buffer.concat(chunks).toString('utf-8'));
+                }
+            });
+        });
+    }
 }
 exports.SearcherService = SearcherService;

package/dist/src/services/WebServerService.d.ts

@@ -0,0 +1,72 @@
+import type { Config } from '../config';
+import type { ISearcher } from '../interfaces';
+import type { IEmbedder } from '../interfaces';
+import type { ILogger } from '../interfaces';
+import { type JsonConfig } from '../config-store';
+/**
+ * Per-field choice lists for the config form. `strict` → render a dropdown that
+ * only accepts a listed value (e.g. the embedding model, tied to the vector
+ * dimension). Non-strict → a combobox: the values are suggestions but free text
+ * is still allowed (e.g. any Ollama model the user has pulled).
+ */
+export interface FieldOption {
+    values: string[];
+    strict: boolean;
+}
+/** Placeholder shown to the browser instead of the real DB password. */
+export declare const PASSWORD_MASK = "********";
+/**
+ * Merge a config submitted from the browser with the stored one. If the
+ * password field still holds the mask (i.e. the user did not change it),
+ * preserve the previously stored password rather than overwriting it with the
+ * placeholder. Pure — no I/O. Exported for unit testing.
+ */
+export declare function mergeConfigForSave(incoming: JsonConfig, existing: JsonConfig | null): JsonConfig;
+/**
+ * Return a copy of the config with the DB password replaced by the mask, so the
+ * real secret never reaches the browser. The masked value round-trips through
+ * `mergeConfigForSave` on save. Pure — no I/O. Exported for unit testing.
+ */
+export declare function maskConfig(cfg: JsonConfig): JsonConfig;
+/**
+ * Local HTTP dashboard. Serves a schema-driven config editor, a project
+ * overview, and the dependency graph. Bind to 127.0.0.1 only — no auth.
+ */
+export declare class WebServer {
+    private readonly searcher;
+    private readonly config;
+    private readonly logger;
+    private readonly embedder;
+    private server?;
+    constructor(searcher: ISearcher, config: Config, logger: ILogger, embedder: IEmbedder);
+    start(port: number, host: string): Promise<void>;
+    stop(): Promise<void>;
+    /** The bound address once started (e.g. `.port` after listen(0)); null otherwise. */
+    address(): {
+        port: number;
+    } | null;
+    private handle;
+    private maskedConfig;
+    private saveConfig;
+    /**
+     * Choice lists for model fields. The embedding model is strict (only
+     * dimension-compatible models); the translate/reranker models are suggested
+     * from the user's installed Ollama models but stay free-text.
+     */
+    private fieldOptions;
+    private installedModels;
+    /** Tabbed graph views (Workspace + one per nested Nx repo). */
+    private graphViews;
+    /** `/api/graph` — the Workspace view's raw `{ nodes, edges }` (back-compat). */
+    private graphData;
+    /**
+     * The full interactive graph page — the same HTML as the standalone
+     * `project-graph.html` (inner tabs, filters, legend, project toggles). The
+     * dashboard's Graph tab embeds this via an iframe rather than re-implementing
+     * vis-network.
+     */
+    private graphPage;
+    private readBody;
+    private json;
+    private html;
+}

package/dist/src/services/WebServerService.js

@@ -0,0 +1,247 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebServer = exports.PASSWORD_MASK = void 0;
+exports.mergeConfigForSave = mergeConfigForSave;
+exports.maskConfig = maskConfig;
+const http = __importStar(require("http"));
+const path = __importStar(require("path"));
+const config_store_1 = require("../config-store");
+const constants_1 = require("../constants");
+const graph_1 = require("../graph");
+const dashboard_1 = require("../web/dashboard");
+/** Placeholder shown to the browser instead of the real DB password. */
+exports.PASSWORD_MASK = '********';
+const MAX_BODY = 1_000_000; // 1 MB — config payloads are tiny
+/**
+ * Merge a config submitted from the browser with the stored one. If the
+ * password field still holds the mask (i.e. the user did not change it),
+ * preserve the previously stored password rather than overwriting it with the
+ * placeholder. Pure — no I/O. Exported for unit testing.
+ */
+function mergeConfigForSave(incoming, existing) {
+    const merged = JSON.parse(JSON.stringify(incoming ?? {}));
+    if (merged.db && merged.db.password === exports.PASSWORD_MASK) {
+        const prev = existing?.db?.password;
+        if (prev !== undefined)
+            merged.db.password = prev;
+        else
+            delete merged.db.password;
+    }
+    return merged;
+}
+/**
+ * Return a copy of the config with the DB password replaced by the mask, so the
+ * real secret never reaches the browser. The masked value round-trips through
+ * `mergeConfigForSave` on save. Pure — no I/O. Exported for unit testing.
+ */
+function maskConfig(cfg) {
+    if (!cfg.db?.password)
+        return cfg;
+    return { ...cfg, db: { ...cfg.db, password: exports.PASSWORD_MASK } };
+}
+/**
+ * Local HTTP dashboard. Serves a schema-driven config editor, a project
+ * overview, and the dependency graph. Bind to 127.0.0.1 only — no auth.
+ */
+class WebServer {
+    searcher;
+    config;
+    logger;
+    embedder;
+    server;
+    constructor(searcher, config, logger, embedder) {
+        this.searcher = searcher;
+        this.config = config;
+        this.logger = logger;
+        this.embedder = embedder;
+    }
+    async start(port, host) {
+        this.server = http.createServer((req, res) => {
+            this.handle(req, res).catch(err => {
+                this.logger.error('WebServer: request failed', { reason: err instanceof Error ? err.message : String(err) });
+                if (!res.headersSent) {
+                    res.writeHead(500);
+                    res.end('Internal error');
+                }
+            });
+        });
+        await new Promise((resolve, reject) => {
+            this.server.once('error', reject);
+            this.server.listen(port, host, () => resolve());
+        });
+        this.logger.info('WebServer: listening', { host, port });
+    }
+    async stop() {
+        if (!this.server)
+            return;
+        await new Promise(resolve => this.server.close(() => resolve()));
+        this.server = undefined;
+    }
+    /** The bound address once started (e.g. `.port` after listen(0)); null otherwise. */
+    address() {
+        const a = this.server?.address();
+        return a && typeof a === 'object' ? { port: a.port } : null;
+    }
+    async handle(req, res) {
+        const url = new URL(req.url ?? '/', 'http://localhost');
+        const p = url.pathname;
+        const m = req.method ?? 'GET';
+        if (m === 'GET' && p === '/')
+            return this.html(res, (0, dashboard_1.renderDashboardHtml)());
+        if (m === 'GET' && p === '/api/schema')
+            return this.json(res, 200, (0, config_store_1.buildJsonSchema)());
+        if (m === 'GET' && p === '/api/defaults')
+            return this.json(res, 200, config_store_1.CONFIG_DEFAULTS);
+        if (m === 'GET' && p === '/api/field-options')
+            return this.json(res, 200, await this.fieldOptions());
+        if (m === 'GET' && p === '/api/config')
+            return this.json(res, 200, this.maskedConfig());
+        if (m === 'PUT' && p === '/api/config')
+            return this.saveConfig(req, res);
+        if (m === 'GET' && p === '/api/projects')
+            return this.json(res, 200, await this.searcher.listProjects());
+        if (m === 'GET' && p === '/api/graph')
+            return this.json(res, 200, await this.graphData());
+        if (m === 'GET' && p === '/graph')
+            return this.html(res, await this.graphPage());
+        this.json(res, 404, { error: 'Not found' });
+    }
+    maskedConfig() {
+        return maskConfig((0, config_store_1.readConfigJson)() ?? {});
+    }
+    async saveConfig(req, res) {
+        let body;
+        try {
+            body = await this.readBody(req);
+        }
+        catch (e) {
+            // Distinguish the size limit from other stream errors.
+            return this.json(res, 413, { error: e instanceof Error ? e.message : 'Request body too large' });
+        }
+        let incoming;
+        try {
+            incoming = JSON.parse(body);
+        }
+        catch {
+            return this.json(res, 400, { error: 'Invalid JSON body' });
+        }
+        const merged = mergeConfigForSave(incoming, (0, config_store_1.readConfigJson)());
+        let validated;
+        try {
+            validated = (0, config_store_1.parseConfig)(merged);
+        }
+        catch (e) {
+            return this.json(res, 400, { error: e instanceof Error ? e.message : String(e) });
+        }
+        (0, config_store_1.writeConfigJson)(validated);
+        this.logger.info('WebServer: config updated');
+        this.json(res, 200, { ok: true });
+    }
+    /**
+     * Choice lists for model fields. The embedding model is strict (only
+     * dimension-compatible models); the translate/reranker models are suggested
+     * from the user's installed Ollama models but stay free-text.
+     */
+    async fieldOptions() {
+        const installed = await this.installedModels();
+        return {
+            'ollama.model': { values: [...constants_1.SUPPORTED_EMBED_MODELS], strict: true },
+            'search.translateModel': { values: installed, strict: false },
+            'reranker.model': { values: installed, strict: false },
+        };
+    }
+    async installedModels() {
+        try {
+            return (await this.embedder.listModels?.()) ?? [];
+        }
+        catch (err) {
+            this.logger.warn('WebServer: could not list Ollama models', { reason: err instanceof Error ? err.message : String(err) });
+            return [];
+        }
+    }
+    /** Tabbed graph views (Workspace + one per nested Nx repo). */
+    async graphViews() {
+        const projects = (await this.searcher.listProjects()).map(p => ({
+            name: p.serviceName,
+            // Real project root (resolved via discovery — handles nested-monorepo
+            // names). Fall back to the flat assumption if listProjects omits it.
+            path: p.path ?? path.join(this.config.workspaceRoot, p.serviceName),
+        }));
+        const projectEdges = await this.searcher.getProjectEdges();
+        return (0, graph_1.buildGraphViews)(projects, projectEdges, this.config.workspaceRoot);
+    }
+    /** `/api/graph` — the Workspace view's raw `{ nodes, edges }` (back-compat). */
+    async graphData() {
+        const views = await this.graphViews();
+        return { nodes: views[0].nodes, edges: views[0].edges };
+    }
+    /**
+     * The full interactive graph page — the same HTML as the standalone
+     * `project-graph.html` (inner tabs, filters, legend, project toggles). The
+     * dashboard's Graph tab embeds this via an iframe rather than re-implementing
+     * vis-network.
+     */
+    async graphPage() {
+        return (0, graph_1.buildHtml)(await this.graphViews());
+    }
+    readBody(req) {
+        return new Promise((resolve, reject) => {
+            let data = '';
+            let tooLarge = false;
+            req.on('data', chunk => {
+                if (tooLarge)
+                    return; // stop growing `data`; keep the socket alive so the 413 flushes
+                data += chunk;
+                if (data.length > MAX_BODY) {
+                    tooLarge = true;
+                    reject(new Error('Request body too large (max 1 MB)'));
+                }
+            });
+            req.on('end', () => resolve(data));
+            req.on('error', reject);
+        });
+    }
+    json(res, status, body) {
+        const s = JSON.stringify(body);
+        res.writeHead(status, { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(s) });
+        res.end(s);
+    }
+    html(res, body) {
+        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+        res.end(body);
+    }
+}
+exports.WebServer = WebServer;