codesearch-mcp 0.0.17-alpha.1 → 0.1.0-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,25 @@
 import type { Config } from '../config';
-import type { IEmbedder } from '../interfaces/IEmbedder';
+import type { IEmbedder, InputType } from '../interfaces';
+import type { ILogger } from '../interfaces';
+import type { EmbedderDeps } from './OpenAICompatibleEmbedder';
 export declare class OllamaEmbedder implements IEmbedder {
     private config;
+    private logger;
+    readonly dimensions: number;
     private client;
     rerank?: (query: string, documents: string[], topN: number) => Promise<number[]>;
-    constructor(config: Config);
-    embed(text: string): Promise<number[]>;
-    translate(text: string, model: string): Promise<string>;
-    private _rerank;
+    constructor(config: Config, logger?: ILogger, deps?: EmbedderDeps);
+    embed(text: string, _inputType?: InputType): Promise<number[]>;
+    embedBatch(texts: string[], _inputType?: InputType): Promise<number[][]>;
+    listModels(): Promise<string[]>;
+    /**
+     * Pull the configured model if it is not already present locally, so a plain
+     * `rag-index` works after switching to (or back to) a local model that was
+     * never pulled — `rag-setup` is no longer the only place that fetches models.
+     * A tagless model name (`bge-m3`) matches its `:latest`/tagged install.
+     * Streams pull progress to the console: a live single-line bar on a TTY, or
+     * de-duplicated status lines otherwise.
+     */
+    ensureModelAvailable(): Promise<void>;
+    private static formatPullProgress;
 }

package/dist/src/services/OllamaEmbedder.js

@@ -2,55 +2,110 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OllamaEmbedder = void 0;
 const ollama_1 = require("ollama");
+const LoggerService_1 = require("./LoggerService");
+const reranker_1 = require("./reranker");
+const constants_1 = require("../constants");
 class OllamaEmbedder {
     config;
+    logger;
+    dimensions;
     client;
     rerank;
-    constructor(config) {
+    constructor(config, logger = LoggerService_1.LoggerService.silent(), deps = {}) {
         this.config = config;
-        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 = logger;
+        this.client = new ollama_1.Ollama({ host: config.embedding.baseURL });
+        this.dimensions = config.embedding.dimensions ?? (0, constants_1.registryDimension)(config.embedding.model) ?? 0;
+        this.rerank = (0, reranker_1.makeReranker)(config, logger, deps);
     }
-    async embed(text) {
+    // Ollama has no query/document asymmetry — inputType is accepted and ignored.
+    async embed(text, _inputType) {
         const { embedding } = await this.client.embeddings({
-            model: this.config.ollama.model,
+            model: this.config.embedding.model,
             prompt: text,
         });
         return embedding;
     }
-    async translate(text, model) {
-        const response = await this.client.chat({
-            model,
-            messages: [{ role: 'user', content: `Translate the following text to English. Return only the translation, no explanations:\n${text}` }],
-        });
-        return response.message.content.trim();
+    async embedBatch(texts, _inputType) {
+        if (texts.length === 0)
+            return [];
+        try {
+            // /api/embed accepts an array input and returns one vector per input.
+            const res = await this.client.embed({ model: this.config.embedding.model, input: texts });
+            if (res.embeddings?.length === texts.length)
+                return res.embeddings;
+            this.logger.warn('OllamaEmbedder: batch embed count mismatch, falling back to sequential', {
+                expected: texts.length, got: res.embeddings?.length ?? 0,
+            });
+        }
+        catch (err) {
+            this.logger.warn('OllamaEmbedder: batch embed failed, falling back to sequential', {
+                reason: err instanceof Error ? err.message : String(err),
+            });
+        }
+        // Sequential fallback — the contract (one vector per input, in order) holds.
+        const out = [];
+        for (const t of texts)
+            out.push(await this.embed(t));
+        return out;
     }
-    async _rerank(query, documents, topN) {
-        const res = await fetch(this.config.ollama.rerankerUrl, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            signal: AbortSignal.timeout(30_000),
-            body: JSON.stringify({
-                model: this.config.ollama.rerankerModel,
-                query,
-                documents,
-                top_n: topN,
-                truncate: true,
-            }),
-        });
-        if (!res.ok) {
-            const body = (await res.text().catch(() => res.statusText)).slice(0, 200);
-            throw new Error(`Ollama rerank failed: ${res.status} ${body}`);
+    async listModels() {
+        const res = await this.client.list();
+        return res.models.map(m => m.name).filter(Boolean).sort();
+    }
+    /**
+     * Pull the configured model if it is not already present locally, so a plain
+     * `rag-index` works after switching to (or back to) a local model that was
+     * never pulled — `rag-setup` is no longer the only place that fetches models.
+     * A tagless model name (`bge-m3`) matches its `:latest`/tagged install.
+     * Streams pull progress to the console: a live single-line bar on a TTY, or
+     * de-duplicated status lines otherwise.
+     */
+    async ensureModelAvailable() {
+        const model = this.config.embedding.model;
+        try {
+            const res = await this.client.list();
+            const present = res.models.some(m => m.name === model || m.name.startsWith(`${model}:`));
+            if (present)
+                return;
+        }
+        catch (err) {
+            // Can't list (Ollama unreachable?) — try the pull; its error is clearer.
+            this.logger.warn('OllamaEmbedder: could not list models before pull', {
+                reason: err instanceof Error ? err.message : String(err),
+            });
+        }
+        console.log(`Pulling Ollama model "${model}" (not found locally)...`);
+        this.logger.info('OllamaEmbedder: pulling model', { model });
+        const stream = await this.client.pull({ model, stream: true });
+        const isTty = Boolean(process.stdout.isTTY);
+        let lastLen = 0;
+        let lastLog = '';
+        for await (const part of stream) {
+            const out = '  ' + OllamaEmbedder.formatPullProgress(part);
+            if (isTty) {
+                process.stdout.write('\r' + out.padEnd(lastLen));
+                lastLen = out.length;
+            }
+            else if (out !== lastLog) {
+                console.log(out);
+                lastLog = out;
+            }
+        }
+        if (isTty && lastLen > 0)
+            process.stdout.write('\r' + ' '.repeat(lastLen) + '\r');
+        console.log(`  ✓ ${model} ready.`);
+    }
+    static formatPullProgress(p) {
+        const status = p.status ?? 'pulling';
+        if (p.total && p.total > 0) {
+            const pct = Math.min(100, Math.floor(((p.completed ?? 0) / p.total) * 100));
+            const width = 24;
+            const filled = Math.round((pct / 100) * width);
+            const bar = '[' + '█'.repeat(filled) + '░'.repeat(width - filled) + ']';
+            return `${status} ${bar} ${pct}% (${((p.completed ?? 0) / 1e6).toFixed(1)}/${(p.total / 1e6).toFixed(1)} MB)`;
         }
-        const data = await res.json();
-        return data.results.map(r => r.index);
+        return status;
     }
 }
 exports.OllamaEmbedder = OllamaEmbedder;