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

package/dist/src/services/MonorepoAwareDiscoveryService.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MonorepoAwareDiscoveryService = void 0;
+exports.toLeafProjects = toLeafProjects;
+const ProjectDiscoveryService_1 = require("./ProjectDiscoveryService");
+/**
+ * Expand discovery units into the leaf projects to index: a nested monorepo
+ * unit (with `children`) becomes its sub-projects; an ordinary project stays
+ * itself. Shared by IndexCommand (indexing loop) and SearcherService (name→path
+ * resolution) so both agree on the leaf set.
+ */
+function toLeafProjects(projects) {
+    return projects.flatMap(p => (p.children && p.children.length > 0 ? p.children : [p]));
+}
+/**
+ * Project discovery that is monorepo-aware.
+ *
+ * When a monorepo is detected (via the resolver), it uses the resolver
+ * to discover projects. Otherwise, it falls back to the original
+ * flat-workspace discovery (directories with package.json). Cross-project
+ * import resolution relies on the tsconfig `paths` attached via
+ * `rootTsConfigPath` — no separate scope map is built.
+ *
+ * Single Responsibility: only discovers projects and workspace metadata.
+ * Does not index or search.
+ *
+ * Implements {@link IProjectDiscovery} so it can be wired as the default
+ * discovery in the container. `discover()` returns one entry per top-level
+ * project: when the root itself is a monorepo, each entry carries the
+ * workspace-wide `rootTsConfigPath`; under a flat root, an ordinary project
+ * gets `rootTsConfigPath: null`, while a top-level directory that is itself a
+ * nested monorepo is returned as a single unit with expanded `children` (see
+ * `toLeafProjects`). `analyzeWorkspace()` exposes the full workspace metadata
+ * (monorepo flag, root tsconfig, project list).
+ */
+class MonorepoAwareDiscoveryService {
+    resolvers;
+    logger;
+    flatDiscovery;
+    constructor(resolvers, logger, 
+    /** Discovery used when no monorepo is detected. Defaults to flat package.json scan. */
+    flatDiscovery = new ProjectDiscoveryService_1.ProjectDiscoveryService()) {
+        this.resolvers = resolvers;
+        this.logger = logger;
+        this.flatDiscovery = flatDiscovery;
+    }
+    /**
+     * IProjectDiscovery contract: enumerate projects in the workspace.
+     * Attaches the workspace-wide root tsconfig to every project so the
+     * indexer can resolve cross-project path aliases.
+     */
+    discover(rootDir) {
+        const workspace = this.analyzeWorkspace(rootDir);
+        // Case A: workspaceRoot itself is a monorepo — attach the workspace-wide
+        // tsconfig to every project (original behavior).
+        if (workspace.isMonorepo) {
+            return workspace.projects.map(p => ({ ...p, rootTsConfigPath: workspace.rootTsConfigPath }));
+        }
+        // Case B: flat workspaceRoot — a top-level project directory may itself be a
+        // nested monorepo (e.g. an Nx repo). Expand such a directory into its
+        // sub-projects as `children`, keeping the repo a single selectable unit.
+        return workspace.projects.map(p => this.expandIfNestedMonorepo(p));
+    }
+    /**
+     * If `project`'s directory is itself a monorepo (resolver detects it),
+     * return it with expanded `children` named `<repo>/<sub-project>`, each
+     * carrying the repo's workspace-wide tsconfig. Otherwise return it unchanged.
+     */
+    expandIfNestedMonorepo(project) {
+        // Ordinary flat project — preserve the original contract (null root tsconfig).
+        const flat = { ...project, rootTsConfigPath: null };
+        const resolver = this.resolvers.find(r => r.isMonorepo(project.path));
+        if (!resolver)
+            return flat;
+        const rootTsConfigPath = resolver.getRootTsConfigPath(project.path);
+        const children = resolver.discoverProjects(project.path).map(c => ({
+            name: `${project.name}/${c.name}`,
+            path: c.path,
+            packageName: c.packageName,
+            type: c.type,
+            rootTsConfigPath,
+        }));
+        if (children.length === 0)
+            return flat;
+        this.logger.info('MonorepoAwareDiscovery: nested monorepo expanded', {
+            repo: project.name,
+            projects: children.length,
+            rootTsConfigPath,
+        });
+        return { ...project, children };
+    }
+    /**
+     * Analyze the workspace root and return full workspace information:
+     * monorepo detection flag, root tsconfig path, and project list.
+     */
+    analyzeWorkspace(rootDir) {
+        for (const resolver of this.resolvers) {
+            if (resolver.isMonorepo(rootDir)) {
+                this.logger.info('MonorepoAwareDiscovery: monorepo detected', { rootDir });
+                const monoProjects = resolver.discoverProjects(rootDir);
+                const rootTsConfigPath = resolver.getRootTsConfigPath(rootDir);
+                const projects = monoProjects.map(p => ({
+                    name: p.name,
+                    path: p.path,
+                    packageName: p.packageName,
+                    type: p.type,
+                }));
+                this.logger.debug('MonorepoAwareDiscovery: workspace analyzed', {
+                    projects: projects.length,
+                    rootTsConfigPath,
+                });
+                return { isMonorepo: true, rootTsConfigPath, projects };
+            }
+        }
+        // Fallback: flat workspace (original behavior) — delegated to the default discovery.
+        this.logger.debug('MonorepoAwareDiscovery: no monorepo detected, using flat discovery', { rootDir });
+        const projects = this.flatDiscovery.discover(rootDir);
+        return {
+            isMonorepo: false,
+            rootTsConfigPath: null,
+            projects,
+        };
+    }
+}
+exports.MonorepoAwareDiscoveryService = MonorepoAwareDiscoveryService;

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

@@ -0,0 +1,45 @@
+import type { IMonorepoResolver, MonorepoProject } from '../interfaces/IMonorepoResolver';
+import type { ILogger } from '../interfaces';
+/**
+ * Nx monorepo resolver.
+ *
+ * Detection: presence of `nx.json` at the workspace root.
+ *
+ * Project discovery strategies (results deduplicated by absolute path):
+ * 1. Read `workspace.json` or `angular.json` → projects map
+ * 2. Scan standard Nx directories (`apps/`, `libs/`, `packages/`) for
+ *    `project.json`, then `package.json` (only when strategy 1 found nothing)
+ * 3. `tsconfig.base.json` `paths` — root-level libs referenced only by path
+ *    alias (e.g. `contracts/`, `interfaces/`) that the directory scan misses
+ * 4. Root-level fallback: treat the workspace root itself as a project
+ *    (standalone Nx setup) when nothing else matched
+ *
+ * tsconfig resolution:
+ * - Returns `tsconfig.base.json` at workspace root (Nx convention)
+ * - Falls back to `tsconfig.json` at workspace root
+ *
+ * Cross-project import resolution is handled by the AST parser via the
+ * workspace-wide tsconfig `paths` (tsconfig.base.json), so no scope map is built here.
+ */
+export declare class NxMonorepoResolver implements IMonorepoResolver {
+    private logger;
+    constructor(logger: ILogger);
+    isMonorepo(rootDir: string): boolean;
+    discoverProjects(rootDir: string): MonorepoProject[];
+    /**
+     * Discover projects from `tsconfig.base.json` `compilerOptions.paths`. Each
+     * alias (e.g. `@scope/interfaces` → `interfaces/src/index.ts`) resolves to a
+     * lib root (the path before `/src/`), which for real Nx libs contains a
+     * project.json. Aliases pointing at non-projects (no project.json/package.json,
+     * e.g. `@env` → `environments/environment.ts`) are skipped.
+     */
+    private discoverFromTsconfigPaths;
+    /** Parse JSON that may contain comments / trailing commas (tsconfig style). */
+    private parseJsonc;
+    getRootTsConfigPath(rootDir: string): string | null;
+    private readWorkspaceJson;
+    private scanDirectory;
+    private tryReadProject;
+    private readPackageName;
+    private inferProjectType;
+}

package/dist/src/services/NxMonorepoResolver.js

@@ -0,0 +1,308 @@
+"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.NxMonorepoResolver = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const file_utils_1 = require("../file-utils");
+/**
+ * Nx monorepo resolver.
+ *
+ * Detection: presence of `nx.json` at the workspace root.
+ *
+ * Project discovery strategies (results deduplicated by absolute path):
+ * 1. Read `workspace.json` or `angular.json` → projects map
+ * 2. Scan standard Nx directories (`apps/`, `libs/`, `packages/`) for
+ *    `project.json`, then `package.json` (only when strategy 1 found nothing)
+ * 3. `tsconfig.base.json` `paths` — root-level libs referenced only by path
+ *    alias (e.g. `contracts/`, `interfaces/`) that the directory scan misses
+ * 4. Root-level fallback: treat the workspace root itself as a project
+ *    (standalone Nx setup) when nothing else matched
+ *
+ * tsconfig resolution:
+ * - Returns `tsconfig.base.json` at workspace root (Nx convention)
+ * - Falls back to `tsconfig.json` at workspace root
+ *
+ * Cross-project import resolution is handled by the AST parser via the
+ * workspace-wide tsconfig `paths` (tsconfig.base.json), so no scope map is built here.
+ */
+class NxMonorepoResolver {
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    isMonorepo(rootDir) {
+        return fs.existsSync(path.join(rootDir, 'nx.json'));
+    }
+    discoverProjects(rootDir) {
+        // Deduplicate across strategies by absolute project path.
+        const byPath = new Map();
+        const add = (p) => { if (p && !byPath.has(p.path))
+            byPath.set(p.path, p); };
+        // Strategy 1: workspace.json / angular.json (authoritative when present)
+        const workspaceProjects = this.readWorkspaceJson(rootDir);
+        for (const p of workspaceProjects)
+            add(p);
+        // Strategy 2 & 3: scan standard directories (only when no workspace.json map)
+        if (byPath.size === 0) {
+            for (const dir of ['apps', 'libs', 'packages']) {
+                const fullDir = path.join(rootDir, dir);
+                if (!fs.existsSync(fullDir))
+                    continue;
+                const type = dir === 'apps' ? 'app' : 'lib';
+                for (const p of this.scanDirectory(fullDir, type, rootDir))
+                    add(p);
+            }
+        }
+        // Strategy 4: tsconfig.base.json `paths` — captures libs that live at the
+        // repo root (e.g. `contracts/`, `interfaces/`) referenced by path aliases,
+        // which the apps/libs/packages scan misses. Only real Nx projects (with a
+        // project.json/package.json) are added; dedup handles overlap with the scan.
+        for (const p of this.discoverFromTsconfigPaths(rootDir))
+            add(p);
+        // Root-level fallback (standalone Nx setup)
+        if (byPath.size === 0) {
+            const rootProject = this.tryReadProject(rootDir, rootDir);
+            if (rootProject)
+                add(rootProject);
+        }
+        const projects = [...byPath.values()];
+        this.logger.debug('NxMonorepoResolver: discovered projects', { count: projects.length });
+        return projects;
+    }
+    /**
+     * Discover projects from `tsconfig.base.json` `compilerOptions.paths`. Each
+     * alias (e.g. `@scope/interfaces` → `interfaces/src/index.ts`) resolves to a
+     * lib root (the path before `/src/`), which for real Nx libs contains a
+     * project.json. Aliases pointing at non-projects (no project.json/package.json,
+     * e.g. `@env` → `environments/environment.ts`) are skipped.
+     */
+    discoverFromTsconfigPaths(rootDir) {
+        const tsconfigPath = this.getRootTsConfigPath(rootDir);
+        if (!tsconfigPath)
+            return [];
+        let json;
+        try {
+            json = this.parseJsonc(fs.readFileSync(tsconfigPath, 'utf-8'));
+        }
+        catch (err) {
+            this.logger.warn('NxMonorepoResolver: failed to parse tsconfig paths', { file: tsconfigPath, reason: err.message });
+            return [];
+        }
+        const co = json?.compilerOptions ?? {};
+        const baseUrl = typeof co.baseUrl === 'string' ? co.baseUrl : '.';
+        const paths = co.paths;
+        if (!paths || typeof paths !== 'object')
+            return [];
+        const projects = [];
+        for (const targets of Object.values(paths)) {
+            const target = Array.isArray(targets) ? targets[0] : targets;
+            if (typeof target !== 'string')
+                continue;
+            const srcIdx = target.indexOf('/src/');
+            const relRoot = srcIdx >= 0 ? target.slice(0, srcIdx) : path.dirname(target);
+            const libRoot = path.resolve(rootDir, baseUrl, relRoot);
+            const project = this.tryReadProject(libRoot, rootDir); // null unless a real project marker exists
+            if (project)
+                projects.push(project);
+        }
+        return projects;
+    }
+    /** Parse JSON that may contain comments / trailing commas (tsconfig style). */
+    parseJsonc(text) {
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            const stripped = text
+                .replace(/\/\*[\s\S]*?\*\//g, '')
+                .replace(/(^|[^:])\/\/.*$/gm, '$1')
+                .replace(/,(\s*[}\]])/g, '$1');
+            return JSON.parse(stripped);
+        }
+    }
+    getRootTsConfigPath(rootDir) {
+        // Nx convention: tsconfig.base.json at workspace root
+        const basePath = path.join(rootDir, 'tsconfig.base.json');
+        if (fs.existsSync(basePath))
+            return basePath;
+        // Fallback: tsconfig.json at workspace root
+        const rootPath = path.join(rootDir, 'tsconfig.json');
+        if (fs.existsSync(rootPath))
+            return rootPath;
+        return null;
+    }
+    // ── Private helpers ─────────────────────────────────────────────────────────
+    readWorkspaceJson(rootDir) {
+        const projects = [];
+        for (const filename of ['workspace.json', 'angular.json']) {
+            const filePath = path.join(rootDir, filename);
+            if (!fs.existsSync(filePath))
+                continue;
+            try {
+                const content = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+                const projectsMap = content.projects ?? {};
+                for (const [name, value] of Object.entries(projectsMap)) {
+                    // value can be a string (path) or an object with a `root` property.
+                    // Guard per-entry: a malformed entry (object without `root`) must not
+                    // abort discovery of the remaining projects in this file.
+                    const rawRoot = typeof value === 'string'
+                        ? value
+                        : value?.root;
+                    if (typeof rawRoot !== 'string' || rawRoot.length === 0) {
+                        this.logger.warn('NxMonorepoResolver: skipping workspace entry without valid root', { file: filePath, name });
+                        continue;
+                    }
+                    const projectPath = path.resolve(rootDir, rawRoot);
+                    if (!fs.existsSync(projectPath))
+                        continue;
+                    const type = this.inferProjectType(projectPath, name);
+                    const packageName = this.readPackageName(projectPath);
+                    projects.push({ name, path: projectPath, packageName, type });
+                }
+            }
+            catch (err) {
+                this.logger.warn('NxMonorepoResolver: failed to parse workspace file', {
+                    file: filePath,
+                    reason: err.message,
+                });
+            }
+        }
+        return projects;
+    }
+    scanDirectory(dir, defaultType, rootDir) {
+        const projects = [];
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return projects;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (file_utils_1.IGNORE_DIRS.has(entry.name))
+                continue;
+            const projectPath = path.join(dir, entry.name);
+            const project = this.tryReadProject(projectPath, rootDir, defaultType);
+            if (project) {
+                projects.push(project);
+                continue;
+            }
+            // Check for nested grouping directories (e.g. libs/shared/utils)
+            const nested = this.scanDirectory(projectPath, defaultType, rootDir);
+            projects.push(...nested);
+        }
+        return projects;
+    }
+    tryReadProject(projectPath, rootDir, defaultType = 'lib') {
+        // Check for project.json (Nx project marker)
+        const projectJsonPath = path.join(projectPath, 'project.json');
+        const packageJsonPath = path.join(projectPath, 'package.json');
+        const hasProjectJson = fs.existsSync(projectJsonPath);
+        const hasPackageJson = fs.existsSync(packageJsonPath);
+        if (!hasProjectJson && !hasPackageJson)
+            return null;
+        let name = path.relative(rootDir, projectPath).replace(/\\/g, '/');
+        let type = defaultType;
+        let packageName = null;
+        // Read project.json for name and type
+        if (hasProjectJson) {
+            try {
+                const projectJson = JSON.parse(fs.readFileSync(projectJsonPath, 'utf-8'));
+                if (projectJson.name)
+                    name = projectJson.name;
+                if (projectJson.projectType === 'application')
+                    type = 'app';
+                else if (projectJson.projectType === 'library')
+                    type = 'lib';
+            }
+            catch (err) {
+                this.logger.warn('NxMonorepoResolver: failed to parse project.json', {
+                    file: projectJsonPath,
+                    reason: err.message,
+                });
+            }
+        }
+        // Read package.json for npm scope
+        if (hasPackageJson) {
+            packageName = this.readPackageName(projectPath);
+            // If no project.json name, use package name without scope
+            if (!hasProjectJson && packageName) {
+                const shortName = packageName.replace(/^@[^/]+\//, '');
+                name = shortName;
+            }
+        }
+        return { name, path: projectPath, packageName, type };
+    }
+    readPackageName(projectPath) {
+        const packageJsonPath = path.join(projectPath, 'package.json');
+        if (!fs.existsSync(packageJsonPath))
+            return null;
+        try {
+            const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+            return typeof pkg.name === 'string' ? pkg.name : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    inferProjectType(projectPath, name) {
+        // Check project.json
+        const projectJsonPath = path.join(projectPath, 'project.json');
+        if (fs.existsSync(projectJsonPath)) {
+            try {
+                const projectJson = JSON.parse(fs.readFileSync(projectJsonPath, 'utf-8'));
+                if (projectJson.projectType === 'application')
+                    return 'app';
+                if (projectJson.projectType === 'library')
+                    return 'lib';
+            }
+            catch { /* fall through */ }
+        }
+        // Infer from path
+        const rel = projectPath.replace(/\\/g, '/');
+        if (rel.includes('/apps/') || rel.includes('/app/'))
+            return 'app';
+        if (rel.includes('/libs/') || rel.includes('/lib/') || rel.includes('/packages/'))
+            return 'lib';
+        // Infer from name
+        if (name.includes('lib') || name.includes('shared') || name.includes('util'))
+            return 'lib';
+        return 'app';
+    }
+}
+exports.NxMonorepoResolver = NxMonorepoResolver;

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

@@ -1,11 +1,14 @@
 import type { Config } from '../config';
-import type { IEmbedder } from '../interfaces/IEmbedder';
+import type { IEmbedder } from '../interfaces';
+import type { ILogger } from '../interfaces';
 export declare class OllamaEmbedder implements IEmbedder {
     private config;
+    private logger;
     private client;
     rerank?: (query: string, documents: string[], topN: number) => Promise<number[]>;
-    constructor(config: Config);
+    constructor(config: Config, logger?: ILogger);
     embed(text: string): Promise<number[]>;
+    listModels(): Promise<string[]>;
     translate(text: string, model: string): Promise<string>;
     private _rerank;
 }

package/dist/src/services/OllamaEmbedder.js

@@ -2,19 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OllamaEmbedder = void 0;
 const ollama_1 = require("ollama");
+const LoggerService_1 = require("./LoggerService");
 class OllamaEmbedder {
     config;
+    logger;
     client;
     rerank;
-    constructor(config) {
+    constructor(config, logger = LoggerService_1.LoggerService.silent()) {
         this.config = config;
+        this.logger = logger;
         this.client = new ollama_1.Ollama({ host: config.ollama.host });
         if (config.search.rerankerEnabled) {
             if (config.ollama.rerankerModel) {
                 this.rerank = this._rerank.bind(this);
             }
             else {
-                console.warn('[OllamaEmbedder] RERANKER_ENABLED=true but RERANKER_MODEL is not set — reranking disabled');
+                this.logger.warn('OllamaEmbedder: rerankerEnabled=true but rerankerModel is not set — reranking disabled');
             }
         }
     }
@@ -25,6 +28,10 @@ class OllamaEmbedder {
         });
         return embedding;
     }
+    async listModels() {
+        const res = await this.client.list();
+        return res.models.map(m => m.name).filter(Boolean).sort();
+    }
     async translate(text, model) {
         const response = await this.client.chat({
             model,

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

@@ -0,0 +1,8 @@
+import type { IProjectDiscovery, DiscoveredProject } from '../interfaces/IProjectDiscovery';
+/**
+ * Default project discovery: finds immediate subdirectories
+ * of the workspace root that contain a package.json.
+ */
+export declare class ProjectDiscoveryService implements IProjectDiscovery {
+    discover(rootDir: string): DiscoveredProject[];
+}

package/dist/src/services/ProjectDiscoveryService.js

@@ -0,0 +1,52 @@
+"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.ProjectDiscoveryService = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const file_utils_1 = require("../file-utils");
+/**
+ * Default project discovery: finds immediate subdirectories
+ * of the workspace root that contain a package.json.
+ */
+class ProjectDiscoveryService {
+    discover(rootDir) {
+        return fs.readdirSync(rootDir, { withFileTypes: true })
+            .filter(d => d.isDirectory() && !file_utils_1.IGNORE_DIRS.has(d.name))
+            .map(d => ({ name: d.name, path: path.join(rootDir, d.name) }))
+            .filter(p => fs.existsSync(path.join(p.path, 'package.json')));
+    }
+}
+exports.ProjectDiscoveryService = ProjectDiscoveryService;

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

@@ -1,8 +1,9 @@
 import type { Config } from '../config';
-import type { IEmbedder } from '../interfaces/IEmbedder';
-import type { DatabaseService } from './DatabaseService';
+import type { IEmbedder } from '../interfaces';
+import type { IDatabase } from '../interfaces';
 import { type ProjectMeta } from '../file-utils';
-import { LoggerService } from './LoggerService';
+import type { ILogger } from '../interfaces';
+import type { IProjectDiscovery } from '../interfaces';
 export interface ChunkRow {
     serviceName: string;
     filePath: string;
@@ -44,6 +45,10 @@ export interface DependencyRow {
 export interface ProjectRow extends ProjectMeta {
     serviceName: string;
     chunks: number;
+    packageName?: string | null;
+    type?: 'app' | 'lib';
+    /** Real filesystem root of the project (resolved via discovery). */
+    path?: string;
 }
 export interface GrepMatch {
     filePath: string;
@@ -67,9 +72,32 @@ export interface SymbolHit {
 export declare class SearcherService {
     private db;
     private embedder;
+    private discovery;
     private config;
     private logger;
-    constructor(db: DatabaseService, embedder: IEmbedder, config: Config, logger?: LoggerService);
+    constructor(db: IDatabase, embedder: IEmbedder, discovery: IProjectDiscovery, config: Config, logger?: ILogger);
+    /** Lazily-built, cached map of project name → real filesystem root. */
+    private rootMap?;
+    /** Cached, lazily-built map of leaf project name → real filesystem root (via discovery). */
+    private projectRootMap;
+    /**
+     * 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).
+     */
+    private resolveProjectRoot;
+    /**
+     * 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).
+     */
+    getProjectEdges(): Promise<{
+        from: string;
+        to: string;
+    }[]>;
     prepareQuery(raw: string): Promise<{
         query: string;
         translated: boolean;
@@ -81,10 +109,10 @@ export declare class SearcherService {
     getDependencies(filePath: string, project: string, symbol?: string | null, transitive?: boolean): Promise<DependencyRow[]>;
     getDependents(filePath: string, project: string, symbol?: string | null, transitive?: boolean): Promise<DependencyRow[]>;
     getCallers(symbol: string, project: string, calleeFile?: string | null): Promise<CallerRow[]>;
-    grepSymbol(symbol: string, project: string, excludeFile: string): {
+    grepSymbol(symbol: string, project: string, excludeFile: string): Promise<{
         matches: GrepMatch[];
         truncated: boolean;
-    };
+    }>;
     findSymbol(name: string, project: string | null, kind: SymbolKind): Promise<{
         hits: SymbolHit[];
         truncated: boolean;
@@ -101,4 +129,9 @@ export declare class SearcherService {
     private walkDir;
     private buildFindSymbolPattern;
     private inferKind;
+    /**
+     * Async wrapper around grep to avoid blocking the event loop.
+     * Returns stdout as a string, or null if grep returned no results or errored.
+     */
+    private spawnGrep;
 }