codesearch-mcp 0.3.0-alpha → 0.4.0-alpha

package/dist/src/ast/graphql-grammar.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GRAPHQL_NAME_RE = exports.GRAPHQL_OPERATION_KIND = exports.GRAPHQL_TYPE_DECORATORS = exports.GRAPHQL_MODULE = void 0;
+exports.decoratorIdentifier = decoratorIdentifier;
+exports.literalStringValue = literalStringValue;
+exports.checkGraphqlGrammar = checkGraphqlGrammar;
+exports.isAbstractGraphqlType = isAbstractGraphqlType;
+exports.findNameProperty = findNameProperty;
+exports.peekThroughWrapper = peekThroughWrapper;
+exports.extractResolverIdentifier = extractResolverIdentifier;
+const ts_morph_1 = require("ts-morph");
+exports.GRAPHQL_MODULE = '@nestjs/graphql';
+exports.GRAPHQL_TYPE_DECORATORS = new Set(['ObjectType', 'InputType', 'InterfaceType']);
+exports.GRAPHQL_OPERATION_KIND = {
+    Query: 'graphql_query', Mutation: 'graphql_mutation', Subscription: 'graphql_subscription',
+};
+exports.GRAPHQL_NAME_RE = /^[_A-Za-z][_0-9A-Za-z]*$/;
+function decoratorIdentifier(dec) {
+    const expr = dec.getExpression();
+    if (ts_morph_1.Node.isCallExpression(expr)) {
+        const callee = expr.getExpression();
+        return ts_morph_1.Node.isIdentifier(callee) ? callee : undefined;
+    }
+    return ts_morph_1.Node.isIdentifier(expr) ? expr : undefined;
+}
+function literalStringValue(node) {
+    if (ts_morph_1.Node.isStringLiteral(node) || ts_morph_1.Node.isNoSubstitutionTemplateLiteral(node))
+        return node.getLiteralValue();
+    return null;
+}
+function checkGraphqlGrammar(name) {
+    return exports.GRAPHQL_NAME_RE.test(name) ? { ok: true, name } : { ok: false, reason: 'invalid-name', value: name };
+}
+function isAbstractGraphqlType(args) {
+    return args.some((arg) => {
+        if (!ts_morph_1.Node.isObjectLiteralExpression(arg))
+            return false;
+        const prop = arg.getProperties().find((p) => {
+            if (!ts_morph_1.Node.isPropertyAssignment(p))
+                return false;
+            const nameNode = p.getNameNode();
+            if (ts_morph_1.Node.isIdentifier(nameNode))
+                return nameNode.getText() === 'isAbstract';
+            if (ts_morph_1.Node.isStringLiteral(nameNode))
+                return nameNode.getLiteralValue() === 'isAbstract';
+            return false;
+        });
+        const init = prop?.getInitializer();
+        return init !== undefined && ts_morph_1.Node.isTrueLiteral(init);
+    });
+}
+function findNameProperty(obj) {
+    return obj.getProperties().find((p) => {
+        if (!ts_morph_1.Node.isPropertyAssignment(p) && !ts_morph_1.Node.isShorthandPropertyAssignment(p))
+            return false;
+        const nameNode = p.getNameNode();
+        if (ts_morph_1.Node.isIdentifier(nameNode))
+            return nameNode.getText() === 'name';
+        if (ts_morph_1.Node.isStringLiteral(nameNode))
+            return nameNode.getLiteralValue() === 'name';
+        return false;
+    });
+}
+function peekThroughWrapper(node) {
+    let current = node;
+    let wrapped = false;
+    while (true) {
+        if (ts_morph_1.Node.isParenthesizedExpression(current) || ts_morph_1.Node.isAsExpression(current) || ts_morph_1.Node.isSatisfiesExpression(current) || ts_morph_1.Node.isNonNullExpression(current)) {
+            current = current.getExpression();
+            wrapped = true;
+            continue;
+        }
+        break;
+    }
+    return { inner: current, wrapped };
+}
+function extractResolverIdentifier(argNode) {
+    let target = argNode;
+    if (ts_morph_1.Node.isArrowFunction(target)) {
+        const body = target.getBody();
+        if (ts_morph_1.Node.isBlock(body))
+            return null;
+        target = body;
+    }
+    if (ts_morph_1.Node.isIdentifier(target))
+        return target;
+    if (ts_morph_1.Node.isArrayLiteralExpression(target)) {
+        const elements = target.getElements();
+        if (elements.length === 1 && ts_morph_1.Node.isIdentifier(elements[0]))
+            return elements[0];
+    }
+    return null;
+}

package/dist/src/ast/node-helpers.d.ts

@@ -0,0 +1,11 @@
+import { Node, type SourceFile } from 'ts-morph';
+export type ResolveDeclaration = (identifier: Node) => Node | undefined;
+export declare function getPos(sourceFile: SourceFile, node: Node): {
+    line: number;
+    col: number;
+};
+export declare function lineTextAt(sourceLines: string[], sourceFile: SourceFile, node: Node): string;
+export declare function memberName(nameNode: Node | undefined): string | null;
+export declare function unwrapExpr(node: Node): Node;
+export declare function unwrapParent(node: Node): Node | undefined;
+export declare function defaultResolveDeclaration(identifier: Node): Node | undefined;

package/dist/src/ast/node-helpers.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPos = getPos;
+exports.lineTextAt = lineTextAt;
+exports.memberName = memberName;
+exports.unwrapExpr = unwrapExpr;
+exports.unwrapParent = unwrapParent;
+exports.defaultResolveDeclaration = defaultResolveDeclaration;
+const ts_morph_1 = require("ts-morph");
+function getPos(sourceFile, node) {
+    const { line, character } = sourceFile.compilerNode
+        .getLineAndCharacterOfPosition(node.getStart());
+    return { line: line + 1, col: character + 1 };
+}
+function lineTextAt(sourceLines, sourceFile, node) {
+    const { line } = getPos(sourceFile, node);
+    return (sourceLines[line - 1] ?? node.getText().split('\n')[0]).trim();
+}
+function memberName(nameNode) {
+    if (!nameNode)
+        return null;
+    if (ts_morph_1.Node.isPrivateIdentifier(nameNode))
+        return nameNode.getText();
+    if (ts_morph_1.Node.isIdentifier(nameNode))
+        return nameNode.getText();
+    if (ts_morph_1.Node.isStringLiteral(nameNode))
+        return nameNode.getLiteralValue();
+    if (ts_morph_1.Node.isNumericLiteral(nameNode))
+        return nameNode.getText();
+    if (ts_morph_1.Node.isComputedPropertyName(nameNode))
+        return nameNode.getText().replace(/\s+/g, '');
+    return null;
+}
+function unwrapExpr(node) {
+    let current = node;
+    while (ts_morph_1.Node.isParenthesizedExpression(current) || ts_morph_1.Node.isAsExpression(current) || ts_morph_1.Node.isSatisfiesExpression(current)) {
+        current = current.getExpression();
+    }
+    return current;
+}
+function unwrapParent(node) {
+    let current = node.getParent();
+    while (current && (ts_morph_1.Node.isParenthesizedExpression(current) || ts_morph_1.Node.isAsExpression(current) || ts_morph_1.Node.isSatisfiesExpression(current))) {
+        current = current.getParent();
+    }
+    return current;
+}
+function defaultResolveDeclaration(identifier) {
+    const sym = identifier.getSymbol();
+    if (!sym)
+        return undefined;
+    const firstDecl = sym.getDeclarations()?.[0];
+    const resolved = firstDecl && ts_morph_1.Node.isImportSpecifier(firstDecl) ? (sym.getAliasedSymbol() ?? sym) : sym;
+    return resolved.getDeclarations()?.[0];
+}

package/dist/src/commands/EvalCommand.d.ts

@@ -1,11 +1,15 @@
-import type { Container } from '../container';
+import type { Config } from '../config';
+import type { IDatabase, IChunkSearch, IProjectCatalog } from '../interfaces';
 import type { ICommand } from './ICommand';
 import type { ICorpusInspector } from '../interfaces/ICorpusInspector';
 export declare class EvalCommand implements ICommand {
-    private container;
+    private db;
+    private chunks;
+    private catalog;
+    private config;
     private argv1;
     private corpusInspector;
     private resultsDir;
-    constructor(container: Container, argv1: string, corpusInspector?: ICorpusInspector, resultsDir?: string);
+    constructor(db: IDatabase, chunks: IChunkSearch, catalog: IProjectCatalog, config: Config, argv1: string, corpusInspector?: ICorpusInspector, resultsDir?: string);
     execute(): Promise<void>;
 }

package/dist/src/commands/EvalCommand.js

@@ -36,87 +36,44 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EvalCommand = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const crypto = __importStar(require("crypto"));
-const child_process_1 = require("child_process");
 const retrieval_eval_1 = require("../retrieval-eval");
 const eval_results_1 = require("../eval-results");
 const eval_corpus_1 = require("../eval-corpus");
-const DEFAULT_SUITE_DIR = path.join('benchmarks', 'eval');
+const eval_vector_index_1 = require("../eval-vector-index");
+const constants_1 = require("../constants");
+const eval_args_1 = require("./eval/eval-args");
+const suite_loader_1 = require("./eval/suite-loader");
+const eval_corpora_1 = require("./eval/eval-corpora");
+const index_inspector_1 = require("./eval/index-inspector");
+const staged_search_1 = require("./eval/staged-search");
+const eval_metadata_1 = require("./eval/eval-metadata");
+const baseline_comparison_1 = require("./eval/baseline-comparison");
 const RESULTS_DIR_NAME = path.join('benchmarks', 'results');
-const KEPT_CORPUS_DIR = path.join('benchmarks', 'corpus');
 const _projectRoot = fs.existsSync(path.join(__dirname, '..', '..', 'package.json'))
     ? path.join(__dirname, '..', '..')
     : path.join(__dirname, '..', '..', '..');
-function gitCommit() {
-    try {
-        return (0, child_process_1.execFileSync)('git', ['rev-parse', 'HEAD'], { cwd: _projectRoot, encoding: 'utf-8' }).trim();
-    }
-    catch {
-        return 'unknown';
-    }
-}
-function hashContent(text) {
-    return crypto.createHash('sha256').update(text).digest('hex').slice(0, 16);
-}
-function parseSuiteFlag(args) {
-    const i = args.indexOf('--suite');
-    if (i === -1)
-        return DEFAULT_SUITE_DIR;
-    const next = args[i + 1];
-    if (next === undefined || next.startsWith('-'))
-        throw new Error('--suite requires a path');
-    return next;
-}
-function parseBaselineFlag(args) {
-    const i = args.indexOf('--baseline');
-    if (i === -1)
-        return null;
-    const next = args[i + 1];
-    if (next === undefined || next.startsWith('-'))
-        throw new Error('--baseline requires a path');
-    return next;
-}
-function parseProjectFlag(args) {
-    const i = args.indexOf('--project');
-    if (i === -1)
-        return null;
-    const next = args[i + 1];
-    if (next === undefined || next.startsWith('-'))
-        throw new Error('--project requires a name');
-    return next;
-}
-function loadSuite(suitePath) {
-    const resolved = path.resolve(_projectRoot, suitePath);
-    const stat = fs.statSync(resolved);
-    if (stat.isDirectory()) {
-        const files = fs.readdirSync(resolved).filter(f => f.endsWith('.json')).sort();
-        const parts = files.map(f => fs.readFileSync(path.join(resolved, f), 'utf-8'));
-        const suites = parts.map(text => (0, retrieval_eval_1.parseSuite)(JSON.parse(text)));
-        return { suite: (0, retrieval_eval_1.mergeSuites)(suites), corpora: (0, retrieval_eval_1.corporaOf)(suites), rawContent: parts.join('\n'), label: 'all' };
-    }
-    const text = fs.readFileSync(resolved, 'utf-8');
-    const suite = (0, retrieval_eval_1.parseSuite)(JSON.parse(text));
-    return { suite, corpora: (0, retrieval_eval_1.corporaOf)([suite]), rawContent: text, label: path.basename(resolved, '.json') };
-}
 class EvalCommand {
-    container;
+    db;
+    chunks;
+    catalog;
+    config;
     argv1;
     corpusInspector;
     resultsDir;
-    constructor(container, argv1, corpusInspector = new eval_corpus_1.GitCorpusInspector(), resultsDir = path.join(_projectRoot, RESULTS_DIR_NAME)) {
-        this.container = container;
+    constructor(db, chunks, catalog, config, argv1, corpusInspector = new eval_corpus_1.GitCorpusInspector(), resultsDir = path.join(_projectRoot, RESULTS_DIR_NAME)) {
+        this.db = db;
+        this.chunks = chunks;
+        this.catalog = catalog;
+        this.config = config;
         this.argv1 = argv1;
         this.corpusInspector = corpusInspector;
         this.resultsDir = resultsDir;
     }
     async execute() {
-        const { db, searcher, config } = this.container;
         const args = process.argv.slice(this.argv1 === 'rag-index' ? 3 : 4);
         let suitePath, baselinePath, projectFilter;
         try {
-            suitePath = parseSuiteFlag(args);
-            baselinePath = parseBaselineFlag(args);
-            projectFilter = parseProjectFlag(args);
+            ({ suitePath, baselinePath, projectFilter } = (0, eval_args_1.parseEvalArgs)(args));
         }
         catch (err) {
             console.error(`\n${err.message}`);
@@ -125,7 +82,7 @@ class EvalCommand {
         }
         let suite, corpora, rawContent, label;
         try {
-            ({ suite, corpora, rawContent, label } = loadSuite(suitePath));
+            ({ suite, corpora, rawContent, label } = (0, suite_loader_1.loadSuite)(_projectRoot, suitePath));
         }
         catch (err) {
             if (err instanceof retrieval_eval_1.EvalSuiteError) {
@@ -146,59 +103,16 @@ class EvalCommand {
             return;
         }
         const runCorpora = corpora.filter(c => suite.cases.some(k => k.corpus === c.root));
-        let refused = false;
-        for (const corpus of runCorpora) {
-            let failures;
-            try {
-                failures = await (0, eval_corpus_1.checkCorpus)(corpus, path.join(config.workspaceRoot, corpus.root), path.join(_projectRoot, KEPT_CORPUS_DIR, corpus.root), this.corpusInspector);
-            }
-            catch (err) {
-                failures = [`cannot inspect the checkout: ${err.message}`];
-            }
-            if (failures.length === 0)
-                continue;
-            refused = true;
-            console.error(`\nCorpus ${corpus.root} does not match ${corpus.commit}:`);
-            for (const f of failures)
-                console.error(`  - ${f}`);
-        }
-        if (refused) {
-            console.error('\nNo search was run and no result file was written.');
-            process.exitCode = 1;
+        if (await (0, eval_corpora_1.refusesMovedCorpus)(runCorpora, this.config, _projectRoot, this.corpusInspector))
             return;
-        }
-        await db.initDbWithSchema();
-        const projectDirs = new Map((await searcher.listProjects()).map(p => [p.serviceName, p.relPath ?? null]));
-        const knownFilesCache = new Map();
-        const inspect = {
-            async isFileIndexed(project, file) {
-                if (!knownFilesCache.has(project))
-                    knownFilesCache.set(project, db.listKnownFiles(project));
-                const files = await knownFilesCache.get(project);
-                return files.includes(file);
-            },
-            async ownerPathsOfFile(project, file) {
-                const rows = await db.query(`SELECT DISTINCT "ownerPath" FROM code_chunk WHERE "serviceName" = $1 AND "filePath" = $2 AND "ownerPath" IS NOT NULL`, [project, file]);
-                return rows.map(r => r.ownerPath);
-            },
-            async projectDir(project) {
-                return projectDirs.get(project) ?? null;
-            },
-        };
-        const toHits = (rows) => rows.map(r => ({ filePath: r.filePath, ownerPath: r.ownerPath ?? null }));
-        const search = async (query, limit, project, threshold) => {
-            const prepared = await searcher.prepareQuery(query);
-            const r = await searcher.searchChunksWithStages(prepared.query, limit, project, threshold, undefined, limit);
-            return {
-                pool: toHits(r.pool),
-                stages: r.stages.reranked
-                    ? { vector: toHits(r.stages.vector), reranked: toHits(r.stages.reranked) }
-                    : { vector: toHits(r.stages.vector) },
-                rerankFailed: r.rerankFailed,
-                fetchLimit: r.fetchLimit,
-                indexParams: r.indexParams,
-            };
-        };
+        await this.db.initDbWithSchema();
+        const projectDirs = new Map((await this.catalog.listProjects()).map(p => [p.serviceName, p.relPath ?? null]));
+        const inspect = (0, index_inspector_1.createIndexInspector)(this.db, projectDirs);
+        const search = (0, staged_search_1.createStagedSearch)(this.chunks);
+        const thresholdWarning = (0, constants_1.thresholdMismatchWarning)(this.config.search.similarityThreshold, this.config.embedding.model);
+        if (thresholdWarning)
+            console.warn(`\n⚠ ${thresholdWarning}\n`);
+        const vectorIndex = await (0, eval_vector_index_1.describeVectorIndex)(this.db);
         let outcome;
         try {
             outcome = await new retrieval_eval_1.RetrievalEvaluator().evaluate(suite, search, inspect, p => console.error((0, eval_results_1.renderProgress)(p)));
@@ -211,52 +125,16 @@ class EvalCommand {
             return;
         }
         const { run, observed } = outcome;
-        const corpusRecords = [];
-        for (const corpus of runCorpora) {
-            const projects = [...projectDirs].filter(([, dir]) => dir !== null && (0, retrieval_eval_1.isUnderRoot)(dir, corpus.root)).map(([name]) => name).sort();
-            const started = Date.now();
-            const record = { ...corpus, projects, ...(await (0, eval_corpus_1.fingerprintCorpus)(db, projects)) };
-            console.log(`Corpus ${corpus.root}: ${record.chunks} chunks in ${projects.length} project(s), fingerprint ${record.fingerprint} (${((Date.now() - started) / 1000).toFixed(1)}s)`);
-            corpusRecords.push(record);
-        }
-        const indexMeta = await db.readIndexMeta();
-        const metadata = {
-            suitePath,
-            suiteHash: hashContent(rawContent),
-            embeddingProvider: config.embedding.provider,
-            embeddingModel: config.embedding.model,
-            rerankerModel: config.reranker.enabled ? config.reranker.model : null,
-            indexMeta: indexMeta ? { provider: indexMeta.provider, model: indexMeta.model, dimensions: indexMeta.dimensions } : null,
-            gitCommit: gitCommit(),
-            timestamp: new Date().toISOString(),
-            conditions: {
-                similarityThreshold: config.search.similarityThreshold,
-                overfetch: config.reranker.overfetch,
-                candidateFloor: config.reranker.candidateFloor,
-                fetchLimit: observed.fetchLimit,
-                efSearch: observed.efSearch,
-                iterativeScan: observed.iterativeScan,
-            },
-            corpora: corpusRecords,
-            liveCases: suite.cases.filter(c => !c.corpus).length,
-        };
+        const corpusRecords = await (0, eval_corpora_1.recordCorpora)(this.db, runCorpora, projectDirs);
+        const indexMeta = await this.db.readIndexMeta();
+        const metadata = (0, eval_metadata_1.buildResultMetadata)({
+            suitePath, rawContent, config: this.config, indexMeta, observed, vectorIndex, corpusRecords,
+            liveCases: suite.cases.filter(c => !c.corpus).length, projectRoot: _projectRoot,
+        });
         const resultFile = { metadata, run };
         for (const line of (0, eval_results_1.renderSummary)(resultFile))
             console.log(line);
-        let comparison;
-        if (baselinePath) {
-            try {
-                const baseline = (0, eval_results_1.readResultFile)(path.resolve(_projectRoot, baselinePath));
-                const cmp = (0, retrieval_eval_1.compare)(baseline, resultFile);
-                comparison = { baselinePath, result: cmp };
-                for (const line of (0, eval_results_1.renderComparison)(baselinePath, cmp))
-                    console.log(line);
-            }
-            catch (err) {
-                console.error(`\nFailed to read baseline '${baselinePath}': ${err.message}`);
-                process.exitCode = 1;
-            }
-        }
+        const comparison = baselinePath ? (0, baseline_comparison_1.compareWithBaseline)(_projectRoot, baselinePath, resultFile) : undefined;
         const { jsonPath, mdPath } = (0, eval_results_1.writeResultFiles)(this.resultsDir, label, resultFile, new Date(), comparison);
         console.log(`\nResults written to:\n  ${path.relative(_projectRoot, jsonPath)}\n  ${path.relative(_projectRoot, mdPath)}`);
     }

package/dist/src/commands/IndexCommand.d.ts

@@ -1,9 +1,15 @@
-import type { Container } from '../container';
+import type { IndexerService } from '../services/IndexerService';
+import type { Config } from '../config';
+import type { IDatabase, IDependencyGraph, IEmbedder, IProjectDiscovery } from '../interfaces';
 import type { ICommand } from './ICommand';
 export declare class IndexCommand implements ICommand {
-    private container;
+    private db;
+    private embedder;
+    private indexer;
+    private dependencies;
+    private discovery;
+    private config;
     private argv1;
-    constructor(container: Container, argv1: string);
+    constructor(db: IDatabase, embedder: IEmbedder, indexer: IndexerService, dependencies: IDependencyGraph, discovery: IProjectDiscovery, config: Config, argv1: string);
     execute(): Promise<void>;
-    private printSummary;
 }

package/dist/src/commands/IndexCommand.js

@@ -5,164 +5,92 @@ const interrupt_1 = require("../interrupt");
 const project_selector_1 = require("../project-selector");
 const graph_1 = require("../graph");
 const MonorepoAwareDiscoveryService_1 = require("../services/MonorepoAwareDiscoveryService");
-const project_scope_1 = require("../project-scope");
 const file_utils_1 = require("../file-utils");
-const legacy_ollama_index_1 = require("../services/legacy-ollama-index");
-function parseProjectFlag(args) {
-    const i = args.indexOf('--project');
-    if (i === -1)
-        return { present: false };
-    const next = args[i + 1];
-    return next !== undefined && !next.startsWith('-') ? { present: true, name: next } : { present: true };
-}
+const index_args_1 = require("../index-args");
+const scan_targets_1 = require("./index/scan-targets");
+const legacy_ollama_guard_1 = require("./index/legacy-ollama-guard");
+const embedding_setup_1 = require("./index/embedding-setup");
+const prune_step_1 = require("./index/prune-step");
+const backend_probe_1 = require("./index/backend-probe");
+const index_summary_1 = require("./index/index-summary");
 class IndexCommand {
-    container;
+    db;
+    embedder;
+    indexer;
+    dependencies;
+    discovery;
+    config;
     argv1;
-    constructor(container, argv1) {
-        this.container = container;
+    constructor(db, embedder, indexer, dependencies, discovery, config, argv1) {
+        this.db = db;
+        this.embedder = embedder;
+        this.indexer = indexer;
+        this.dependencies = dependencies;
+        this.discovery = discovery;
+        this.config = config;
         this.argv1 = argv1;
     }
     async execute() {
-        const { db, indexer, searcher, config, discovery, embedder } = this.container;
-        const args = process.argv.slice(this.argv1 === 'rag-index' ? 2 : 3);
-        const force = args.includes('--reindex');
-        const forceSelect = args.includes('--select');
-        const projectFlag = parseProjectFlag(args);
-        let discovered;
-        try {
-            discovered = discovery.discover(config.workspaceRoot);
-        }
-        catch (err) {
-            console.error(`\n${err.message}`);
-            process.exitCode = 1;
+        const args = (0, index_args_1.parseIndexArgs)(process.argv.slice(this.argv1 === 'rag-index' ? 2 : 3));
+        const { force, forceSelect } = args;
+        const targets = await (0, scan_targets_1.resolveScanTargets)(this.discovery, this.config, args);
+        if (!targets)
+            return;
+        await this.db.initDbWithSchema();
+        if (!force && await (0, legacy_ollama_guard_1.refusesLegacyOllamaIndex)(this.db, this.config))
             return;
-        }
-        let scanTargets;
-        if (projectFlag.present) {
-            let name = projectFlag.name;
-            if (name === undefined) {
-                if (discovered.length === 0) {
-                    console.error('\nNo projects available to select.');
-                    process.exitCode = 1;
-                    return;
-                }
-                name = await (0, project_selector_1.selectSingleProject)(discovered);
-                if (name === undefined) {
-                    process.exitCode = 1;
-                    return;
-                }
-            }
-            const { targets, notFound } = (0, project_scope_1.resolveProjectNames)([name], discovered);
-            if (notFound.length > 0) {
-                const available = (0, project_scope_1.listAvailableNames)(discovered).join(', ');
-                console.error(`\nProject '${notFound[0]}' not found. Available projects: ${available}`);
-                process.exitCode = 1;
-                return;
-            }
-            scanTargets = targets;
-        }
-        await db.initDbWithSchema();
-        if (!force) {
-            let identity;
-            try {
-                identity = await (0, legacy_ollama_index_1.resolveIndexedIdentity)(db);
-            }
-            catch (err) {
-                console.error(`\n${err.message}`);
-                process.exitCode = 1;
-                return;
-            }
-            if (identity?.provider === 'ollama') {
-                console.error(`\nThe existing index was built with ${identity.provider}/${identity.model}, but "ollama" is no ` +
-                    `longer a supported embedding provider (configured: ${config.embedding.provider}/${config.embedding.model}). ` +
-                    `Run \`rag-index --reindex\` to confirm rebuilding the index under the configured provider.`);
-                process.exitCode = 1;
-                return;
-            }
-        }
         let projects;
-        if (scanTargets) {
-            projects = scanTargets;
+        if (targets.scanTargets) {
+            projects = targets.scanTargets;
         }
         else {
-            const selected = await new project_selector_1.ProjectSelector(config.workspaceRoot).select(discovered, forceSelect);
+            const selected = await new project_selector_1.ProjectSelector(this.config.workspaceRoot).select(targets.discovered, forceSelect);
             if (selected.length === 0)
                 return;
             projects = (0, MonorepoAwareDiscoveryService_1.toLeafProjects)(selected);
         }
-        const fullLeafProjects = (0, MonorepoAwareDiscoveryService_1.toLeafProjects)(discovered);
-        try {
-            await embedder.ensureModelAvailable?.();
-            const meta = await indexer.prepareEmbeddingSchema();
-            console.log(`Embedding: ${meta.provider} / ${meta.model} (${meta.dimensions} dims)`);
-        }
-        catch (err) {
-            console.error(`\nEmbedding setup failed: ${err.message}`);
-            process.exitCode = 1;
+        const fullLeafProjects = (0, MonorepoAwareDiscoveryService_1.toLeafProjects)(targets.discovered);
+        if (!await (0, embedding_setup_1.prepareEmbedding)(this.embedder, this.indexer))
             return;
-        }
         const controller = new AbortController();
         const teardown = (0, interrupt_1.setupInterrupt)(controller);
         try {
-            if (!scanTargets) {
-                let pruneResult;
-                try {
-                    pruneResult = await indexer.pruneProjects(projects.map(p => p.name));
-                }
-                catch (err) {
-                    console.error(`\nPruning failed: ${err.message}`);
-                    process.exitCode = 1;
-                    return;
-                }
-                const { removed, failed } = pruneResult;
-                for (const name of removed) {
-                    console.log(`Removed project ${name} (not selected)`);
-                }
-                if (failed.length > 0) {
-                    process.exitCode = 1;
-                }
-            }
+            if (!targets.scanTargets && !await (0, prune_step_1.pruneUnselected)(this.indexer, projects))
+                return;
             const filesPerProject = projects.map(p => (0, file_utils_1.collectFiles)(p.path, (0, file_utils_1.loadIgnore)(p.path), p.path));
             const totalFiles = filesPerProject.reduce((sum, f) => sum + f.length, 0);
             console.log(`\n${projects.length} projects — ${totalFiles} files total`);
             if (force)
                 console.log('Reindex mode: all files will be re-indexed.');
-            const allStats = await indexer.scanProjects(projects, force, controller.signal, filesPerProject);
-            if (controller.signal.aborted)
+            const allStats = await this.indexer.scanProjects(projects, force, controller.signal, filesPerProject);
+            const interrupted = controller.signal.aborted;
+            if (interrupted)
                 console.log('\nIndexing interrupted.');
-            this.printSummary(allStats);
-            if (!controller.signal.aborted) {
+            (0, index_summary_1.printIndexSummary)(allStats);
+            const sum = (field) => allStats.reduce((total, s) => total + s[field], 0);
+            const failed = sum('failed');
+            const total = failed + sum('indexed') + sum('skipped');
+            if (failed > 0) {
+                console.error(`Indexing finished with ${failed} of ${total} file(s) failed.`);
+            }
+            if (!interrupted) {
                 try {
-                    const projectEdges = await searcher.getProjectEdges();
-                    (0, graph_1.generateProjectGraph)(fullLeafProjects, projectEdges, config.workspaceRoot);
+                    const projectEdges = await this.dependencies.getProjectEdges();
+                    (0, graph_1.generateProjectGraph)(fullLeafProjects, projectEdges, this.config.workspaceRoot);
                 }
                 catch (err) {
                     console.error(`  ⚠ Could not build project graph: ${err.message}`);
                 }
             }
+            if (failed > 0) {
+                const nothingUsable = sum('skipped') === 0 && sum('chunks') === 0;
+                const alreadyFailed = interrupted || !!process.exitCode || nothingUsable;
+                process.exitCode = alreadyFailed || !(await (0, backend_probe_1.isBackendAvailable)(this.db, this.embedder)) ? 1 : 2;
+            }
         }
         finally {
             teardown();
         }
     }
-    printSummary(allStats) {
-        const cols = { name: 30, num: 8 };
-        const line = '─'.repeat(cols.name + cols.num * 5 + 5);
-        console.log('\n=== Indexing Summary ===');
-        console.log('Service'.padEnd(cols.name), 'Indexed'.padStart(cols.num), 'Skipped'.padStart(cols.num), 'Failed'.padStart(cols.num), 'Chunks'.padStart(cols.num), 'Time(s)'.padStart(cols.num));
-        console.log(line);
-        for (const s of allStats) {
-            console.log(s.serviceName.padEnd(cols.name), String(s.indexed).padStart(cols.num), String(s.skipped).padStart(cols.num), String(s.failed).padStart(cols.num), String(s.chunks).padStart(cols.num), String(s.elapsedSec).padStart(cols.num));
-        }
-        console.log(line);
-        const total = allStats.reduce((acc, s) => ({
-            indexed: acc.indexed + s.indexed,
-            skipped: acc.skipped + s.skipped,
-            failed: acc.failed + s.failed,
-            chunks: acc.chunks + s.chunks,
-            elapsedSec: acc.elapsedSec + s.elapsedSec,
-        }), { indexed: 0, skipped: 0, failed: 0, chunks: 0, elapsedSec: 0 });
-        console.log('TOTAL'.padEnd(cols.name), String(total.indexed).padStart(cols.num), String(total.skipped).padStart(cols.num), String(total.failed).padStart(cols.num), String(total.chunks).padStart(cols.num), String(total.elapsedSec.toFixed(1)).padStart(cols.num));
-    }
 }
 exports.IndexCommand = IndexCommand;