@wei840222/qmd 2026.8.23

package/dist/collections.js

@@ -0,0 +1,433 @@
+/**
+ * Collections configuration management
+ *
+ * This module manages the YAML-based collection configuration at ~/.config/qmd/index.yml.
+ * Collections define which directories to index and their associated contexts.
+ */
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from "fs";
+import { randomUUID } from "node:crypto";
+import { basename, join, dirname, resolve } from "path";
+import { qmdHomedir } from "./paths.js";
+import YAML from "yaml";
+// ============================================================================
+// Configuration paths
+// ============================================================================
+// Current index name (default: "index")
+let currentIndexName = "index";
+export function createCollectionConfigSource(source) {
+    if (source?.config) {
+        source.config.collections ??= {};
+        return { type: "inline", config: source.config };
+    }
+    return { type: "file", path: source?.configPath };
+}
+let configSource = createCollectionConfigSource();
+let configWriteFaultInjector;
+/** @internal Test-only fault injection for crash-safety verification. */
+export function setConfigWriteFaultInjectorForTests(injector) {
+    configWriteFaultInjector = injector;
+}
+/**
+ * Set the config source for SDK mode.
+ * - File path: load/save from a specific YAML file
+ * - Inline config: use an in-memory CollectionConfig (saveConfig updates in place, no file I/O)
+ * - undefined: reset to default file-based config
+ */
+export function setConfigSource(source) {
+    configSource = createCollectionConfigSource(source);
+}
+/**
+ * Set the current index name for config file lookup
+ * Config file will be ~/.config/qmd/{indexName}.yml
+ */
+export function setConfigIndexName(name) {
+    // Resolve relative paths to absolute paths and sanitize for use as filename
+    if (name.includes('/')) {
+        const absolutePath = resolve(process.cwd(), name);
+        // Replace path separators with underscores to create a valid filename
+        currentIndexName = absolutePath.replace(/\//g, '_').replace(/^_/, '');
+    }
+    else {
+        currentIndexName = name;
+    }
+}
+export function getConfigDir() {
+    // Allow override via QMD_CONFIG_DIR for testing
+    if (process.env.QMD_CONFIG_DIR) {
+        return process.env.QMD_CONFIG_DIR;
+    }
+    // Respect XDG Base Directory specification (consistent with store.ts)
+    if (process.env.XDG_CONFIG_HOME) {
+        return join(process.env.XDG_CONFIG_HOME, "qmd");
+    }
+    return join(qmdHomedir(), ".config", "qmd");
+}
+function getConfigFilePath() {
+    return join(getConfigDir(), `${currentIndexName}.yml`);
+}
+/**
+ * Find a project-local QMD config by walking upward from startDir.
+ * The local config lives at .qmd/index.yaml or .qmd/index.yml and,
+ * when used by the CLI, keeps both config and index DB writes inside
+ * the project instead of the global ~/.config / ~/.cache locations.
+ */
+export function findLocalConfigPath(startDir = process.cwd()) {
+    let dir = resolve(startDir);
+    while (true) {
+        const qmdDir = join(dir, ".qmd");
+        const yamlPath = join(qmdDir, "index.yaml");
+        if (existsSync(yamlPath))
+            return yamlPath;
+        const ymlPath = join(qmdDir, "index.yml");
+        if (existsSync(ymlPath))
+            return ymlPath;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+}
+/** Return the local SQLite index path paired with a local .qmd/index.yaml file. */
+export function getLocalDbPath(configPath) {
+    return join(dirname(configPath), "index.sqlite");
+}
+/**
+ * Ensure config directory exists
+ */
+function ensureConfigDir() {
+    const configDir = getConfigDir();
+    if (!existsSync(configDir)) {
+        mkdirSync(configDir, { recursive: true });
+    }
+}
+// ============================================================================
+// Core functions
+// ============================================================================
+/**
+ * Load configuration from the configured source.
+ * - Inline config: returns the in-memory object directly
+ * - File-based: reads from YAML file (default ~/.config/qmd/index.yml)
+ * Returns empty config if file doesn't exist
+ */
+export function loadConfig(source = configSource) {
+    // SDK inline config mode
+    if (source.type === 'inline') {
+        return source.config;
+    }
+    // File-based config (SDK custom path or default)
+    const configPath = source.path || getConfigFilePath();
+    if (!existsSync(configPath)) {
+        return { collections: {} };
+    }
+    try {
+        const content = readFileSync(configPath, "utf-8");
+        const parsed = YAML.parse(content);
+        const config = parsed ?? { collections: {} };
+        // Ensure collections object exists
+        if (!config.collections) {
+            config.collections = {};
+        }
+        return config;
+    }
+    catch (error) {
+        throw new Error(`Failed to parse ${configPath}: ${error}`);
+    }
+}
+/**
+ * Save configuration to the configured source.
+ * - Inline config: updates the in-memory object (no file I/O)
+ * - File-based: writes to YAML file (default ~/.config/qmd/index.yml)
+ */
+export function saveConfig(config, source = configSource) {
+    // SDK inline config mode: update in place, no file I/O
+    if (source.type === 'inline') {
+        source.config = config;
+        return;
+    }
+    const configPath = source.path || getConfigFilePath();
+    const configDir = dirname(configPath);
+    if (!existsSync(configDir)) {
+        mkdirSync(configDir, { recursive: true });
+    }
+    try {
+        const yaml = YAML.stringify(config, {
+            indent: 2,
+            lineWidth: 0, // Don't wrap lines
+        });
+        const temporaryPath = join(configDir, `.${basename(configPath)}.${process.pid}.${randomUUID()}.tmp`);
+        let temporaryFd;
+        let renamed = false;
+        try {
+            temporaryFd = openSync(temporaryPath, "wx", 0o600);
+            configWriteFaultInjector?.("before-temp-write");
+            writeFileSync(temporaryFd, yaml, "utf8");
+            fsyncSync(temporaryFd);
+            closeSync(temporaryFd);
+            temporaryFd = undefined;
+            configWriteFaultInjector?.("before-rename");
+            renameSync(temporaryPath, configPath);
+            renamed = true;
+            const directoryFd = openSync(configDir, "r");
+            try {
+                fsyncSync(directoryFd);
+            }
+            finally {
+                closeSync(directoryFd);
+            }
+        }
+        finally {
+            if (temporaryFd !== undefined)
+                closeSync(temporaryFd);
+            if (!renamed && existsSync(temporaryPath))
+                unlinkSync(temporaryPath);
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to write ${configPath}: ${error}`);
+    }
+}
+/**
+ * Get a specific collection by name
+ * Returns null if not found
+ */
+export function getCollection(name) {
+    const config = loadConfig();
+    const collection = config.collections[name];
+    if (!collection) {
+        return null;
+    }
+    return { name, ...collection };
+}
+/**
+ * List all collections
+ */
+export function listCollections() {
+    const config = loadConfig();
+    return Object.entries(config.collections).map(([name, collection]) => ({
+        name,
+        ...collection,
+    }));
+}
+/**
+ * Get collections that are included by default in queries
+ */
+export function getDefaultCollections() {
+    return listCollections().filter(c => c.includeByDefault !== false);
+}
+/**
+ * Get collection names that are included by default
+ */
+export function getDefaultCollectionNames() {
+    return getDefaultCollections().map(c => c.name);
+}
+/**
+ * Update a collection's settings
+ */
+export function updateCollectionSettings(name, settings) {
+    const config = loadConfig();
+    const collection = config.collections[name];
+    if (!collection)
+        return false;
+    if (settings.update !== undefined) {
+        if (settings.update === null) {
+            delete collection.update;
+        }
+        else {
+            collection.update = settings.update;
+        }
+    }
+    if (settings.includeByDefault !== undefined) {
+        if (settings.includeByDefault === true) {
+            // true is default, remove the field
+            delete collection.includeByDefault;
+        }
+        else {
+            collection.includeByDefault = settings.includeByDefault;
+        }
+    }
+    saveConfig(config);
+    return true;
+}
+/**
+ * Add or update a collection
+ */
+export function addCollection(name, path, pattern = "**/*.md", ignore, source = configSource) {
+    const config = loadConfig(source);
+    config.collections[name] = {
+        path,
+        pattern,
+        ignore: ignore ?? config.collections[name]?.ignore,
+        context: config.collections[name]?.context, // Preserve existing context
+    };
+    saveConfig(config, source);
+}
+/**
+ * Remove a collection
+ */
+export function removeCollection(name, source = configSource) {
+    const config = loadConfig(source);
+    if (!config.collections[name]) {
+        return false;
+    }
+    delete config.collections[name];
+    saveConfig(config, source);
+    return true;
+}
+/**
+ * Rename a collection
+ */
+export function renameCollection(oldName, newName, source = configSource) {
+    const config = loadConfig(source);
+    if (!config.collections[oldName]) {
+        return false;
+    }
+    if (config.collections[newName]) {
+        throw new Error(`Collection '${newName}' already exists`);
+    }
+    config.collections[newName] = config.collections[oldName];
+    delete config.collections[oldName];
+    saveConfig(config, source);
+    return true;
+}
+// ============================================================================
+// Context management
+// ============================================================================
+/**
+ * Get global context
+ */
+export function getGlobalContext() {
+    const config = loadConfig();
+    return config.global_context;
+}
+/**
+ * Set global context
+ */
+export function setGlobalContext(context, source = configSource) {
+    const config = loadConfig(source);
+    config.global_context = context;
+    saveConfig(config, source);
+}
+/**
+ * Get all contexts for a collection
+ */
+export function getContexts(collectionName) {
+    const collection = getCollection(collectionName);
+    return collection?.context;
+}
+/**
+ * Add or update a context for a specific path in a collection
+ */
+export function addContext(collectionName, pathPrefix, contextText, source = configSource) {
+    const config = loadConfig(source);
+    const collection = config.collections[collectionName];
+    if (!collection) {
+        return false;
+    }
+    if (!collection.context) {
+        collection.context = {};
+    }
+    collection.context[pathPrefix] = contextText;
+    saveConfig(config, source);
+    return true;
+}
+/**
+ * Remove a context from a collection
+ */
+export function removeContext(collectionName, pathPrefix, source = configSource) {
+    const config = loadConfig(source);
+    const collection = config.collections[collectionName];
+    if (!collection?.context?.[pathPrefix]) {
+        return false;
+    }
+    delete collection.context[pathPrefix];
+    // Remove empty context object
+    if (Object.keys(collection.context).length === 0) {
+        delete collection.context;
+    }
+    saveConfig(config, source);
+    return true;
+}
+/**
+ * List all contexts across all collections
+ */
+export function listAllContexts() {
+    const config = loadConfig();
+    const results = [];
+    // Add global context if present
+    if (config.global_context) {
+        results.push({
+            collection: "*",
+            path: "/",
+            context: config.global_context,
+        });
+    }
+    // Add collection contexts
+    for (const [name, collection] of Object.entries(config.collections)) {
+        if (collection.context) {
+            for (const [path, context] of Object.entries(collection.context)) {
+                results.push({
+                    collection: name,
+                    path,
+                    context,
+                });
+            }
+        }
+    }
+    return results;
+}
+/**
+ * Find best matching context for a given collection and path
+ * Returns the most specific matching context (longest path prefix match)
+ */
+export function findContextForPath(collectionName, filePath) {
+    const config = loadConfig();
+    const collection = config.collections[collectionName];
+    if (!collection?.context) {
+        return config.global_context;
+    }
+    // Find all matching prefixes
+    const matches = [];
+    for (const [prefix, context] of Object.entries(collection.context)) {
+        // Normalize paths for comparison
+        const normalizedPath = filePath.startsWith("/") ? filePath : `/${filePath}`;
+        const normalizedPrefix = prefix.startsWith("/") ? prefix : `/${prefix}`;
+        if (normalizedPath.startsWith(normalizedPrefix)) {
+            matches.push({ prefix: normalizedPrefix, context });
+        }
+    }
+    // Return most specific match (longest prefix)
+    if (matches.length > 0) {
+        matches.sort((a, b) => b.prefix.length - a.prefix.length);
+        return matches[0].context;
+    }
+    // Fallback to global context
+    return config.global_context;
+}
+// ============================================================================
+// Utility functions
+// ============================================================================
+/**
+ * Get the config file path (useful for error messages)
+ */
+export function getConfigPath() {
+    if (configSource.type === 'inline')
+        return '<inline>';
+    return configSource.path || getConfigFilePath();
+}
+/**
+ * Check if config file exists
+ */
+export function configExists() {
+    if (configSource.type === 'inline')
+        return true;
+    const path = configSource.path || getConfigFilePath();
+    return existsSync(path);
+}
+/**
+ * Validate a collection name
+ * Collection names must be valid and not contain special characters
+ */
+export function isValidCollectionName(name) {
+    // Allow alphanumeric, hyphens, underscores
+    return /^[a-zA-Z0-9_-]+$/.test(name);
+}

package/dist/db.d.ts

@@ -0,0 +1,65 @@
+/**
+ * db.ts - Cross-runtime SQLite compatibility layer
+ *
+ * Provides a unified Database export that works under both Bun (bun:sqlite)
+ * and Node.js (better-sqlite3). The APIs are nearly identical — the main
+ * difference is the import path.
+ *
+ * On macOS, Apple's system SQLite is compiled with SQLITE_OMIT_LOAD_EXTENSION,
+ * which prevents loading native extensions like sqlite-vec. When running under
+ * Bun we call Database.setCustomSQLite() to swap in Homebrew's full-featured
+ * SQLite build before creating any database instances.
+ */
+export declare const isBun: boolean;
+export type SQLiteValue = string | number | bigint | Buffer | Uint8Array | Float32Array | null;
+export type SQLiteParams = readonly SQLiteValue[];
+/**
+ * Open a SQLite database. Works with both bun:sqlite and better-sqlite3.
+ *
+ * `bun:sqlite` and `better-sqlite3` both default `busy_timeout` to 0, so
+ * concurrent writers throw `SQLITE_BUSY` instead of waiting. WAL improves
+ * read-while-write concurrency but does not serialise writers. Setting the
+ * timeout at connection open makes parallel processes (e.g. an `update` or
+ * `query` racing a long `embed`, or a first-open schema migration racing any
+ * routine command) queue at batch boundaries instead of failing on contact.
+ *
+ * WAL is enabled here too (with a bounded retry) so connection-level pragmas
+ * live in one place and the cold-database journal migration survives concurrent
+ * opens.
+ *
+ * Default 120_000 ms outlasts the worst-case batch commit on a multi-GB
+ * index. Override with `QMD_SQLITE_BUSY_TIMEOUT` (value in milliseconds; `0`
+ * restores the upstream fail-fast behaviour). See
+ * https://bun.sh/docs/api/sqlite#busy-timeout.
+ */
+export declare function openDatabase(path: string): Database;
+/** Open an existing database without changing journal mode, schema, or user data. */
+export declare function openReadOnlyDatabase(path: string): Database;
+/**
+ * Common subset of the Database interface used throughout QMD.
+ */
+export interface Database {
+    exec(sql: string): void;
+    prepare(sql: string): Statement;
+    loadExtension(path: string): void;
+    transaction<T extends (...args: SQLiteValue[]) => unknown>(fn: T): T & {
+        immediate: T;
+    };
+    close(): void;
+}
+export interface Statement {
+    run(...params: SQLiteValue[]): {
+        changes: number;
+        lastInsertRowid: number | bigint;
+    };
+    get<T = unknown>(...params: SQLiteValue[]): T | undefined;
+    all<T = unknown>(...params: SQLiteValue[]): T[];
+    iterate<T = unknown>(...params: SQLiteValue[]): IterableIterator<T>;
+}
+/**
+ * Load the sqlite-vec extension into a database.
+ *
+ * Throws with platform-specific fix instructions when the extension is
+ * unavailable.
+ */
+export declare function loadSqliteVec(db: Database): void;

package/dist/db.js

@@ -0,0 +1,143 @@
+/**
+ * db.ts - Cross-runtime SQLite compatibility layer
+ *
+ * Provides a unified Database export that works under both Bun (bun:sqlite)
+ * and Node.js (better-sqlite3). The APIs are nearly identical — the main
+ * difference is the import path.
+ *
+ * On macOS, Apple's system SQLite is compiled with SQLITE_OMIT_LOAD_EXTENSION,
+ * which prevents loading native extensions like sqlite-vec. When running under
+ * Bun we call Database.setCustomSQLite() to swap in Homebrew's full-featured
+ * SQLite build before creating any database instances.
+ */
+export const isBun = "Bun" in globalThis;
+let _Database;
+let _sqliteVecLoad;
+if (isBun) {
+    // Dynamic string prevents tsc from resolving bun:sqlite on Node.js builds
+    const bunSqlite = "bun:" + "sqlite";
+    const BunDatabase = (await import(/* @vite-ignore */ bunSqlite)).Database;
+    // See: https://bun.com/docs/runtime/sqlite#setcustomsqlite
+    if (process.platform === "darwin") {
+        const homebrewPaths = [
+            "/opt/homebrew/opt/sqlite/lib/libsqlite3.dylib", // Apple Silicon
+            "/usr/local/opt/sqlite/lib/libsqlite3.dylib", // Intel
+        ];
+        for (const p of homebrewPaths) {
+            try {
+                BunDatabase.setCustomSQLite(p);
+                break;
+            }
+            catch { }
+        }
+    }
+    _Database = BunDatabase;
+    // setCustomSQLite may have silently failed — test that extensions actually work.
+    try {
+        const { getLoadablePath } = await import("sqlite-vec");
+        const vecPath = getLoadablePath();
+        const testDb = new BunDatabase(":memory:");
+        testDb.loadExtension(vecPath);
+        testDb.close();
+        _sqliteVecLoad = (db) => db.loadExtension(vecPath);
+    }
+    catch {
+        // Vector search won't work, but BM25 and other operations are unaffected.
+        _sqliteVecLoad = null;
+    }
+}
+else {
+    // Dual-runtime: better-sqlite3 matches Database at runtime; published types do not share an interface with bun:sqlite.
+    _Database = (await import("better-sqlite3")).default;
+    const sqliteVec = await import("sqlite-vec");
+    _sqliteVecLoad = (db) => sqliteVec.load(db);
+}
+function isBusyError(err) {
+    if (typeof err !== "object" || err === null)
+        return false;
+    const code = err.code;
+    if (code === "SQLITE_BUSY" || code === "SQLITE_BUSY_SNAPSHOT")
+        return true;
+    const message = err.message;
+    return typeof message === "string" && /database is locked|database is busy|SQLITE_BUSY/i.test(message);
+}
+function sleepSync(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+/**
+ * Switch a connection to WAL, retrying on `SQLITE_BUSY` within the busy-timeout
+ * budget. Unlike ordinary writes, migrating the journal needs a brief exclusive
+ * lock and does NOT invoke the busy handler, so concurrent first-time opens of a
+ * cold database throw "database is locked" even with `busy_timeout` set. Once the
+ * database is already WAL the pragma is a cheap no-op that does not contend.
+ */
+function enableWal(db, budgetMs) {
+    const deadline = Date.now() + Math.max(budgetMs, 0);
+    for (let attempt = 0;; attempt++) {
+        try {
+            db.exec("PRAGMA journal_mode = WAL");
+            return;
+        }
+        catch (err) {
+            if (!isBusyError(err) || Date.now() >= deadline)
+                throw err;
+            sleepSync(Math.min(5 + attempt, 25));
+        }
+    }
+}
+/**
+ * Open a SQLite database. Works with both bun:sqlite and better-sqlite3.
+ *
+ * `bun:sqlite` and `better-sqlite3` both default `busy_timeout` to 0, so
+ * concurrent writers throw `SQLITE_BUSY` instead of waiting. WAL improves
+ * read-while-write concurrency but does not serialise writers. Setting the
+ * timeout at connection open makes parallel processes (e.g. an `update` or
+ * `query` racing a long `embed`, or a first-open schema migration racing any
+ * routine command) queue at batch boundaries instead of failing on contact.
+ *
+ * WAL is enabled here too (with a bounded retry) so connection-level pragmas
+ * live in one place and the cold-database journal migration survives concurrent
+ * opens.
+ *
+ * Default 120_000 ms outlasts the worst-case batch commit on a multi-GB
+ * index. Override with `QMD_SQLITE_BUSY_TIMEOUT` (value in milliseconds; `0`
+ * restores the upstream fail-fast behaviour). See
+ * https://bun.sh/docs/api/sqlite#busy-timeout.
+ */
+export function openDatabase(path) {
+    const db = new _Database(path);
+    const raw = process.env.QMD_SQLITE_BUSY_TIMEOUT;
+    const parsed = raw !== undefined && raw !== "" ? Number(raw) : Number.NaN;
+    const busyTimeoutMs = Number.isFinite(parsed) && parsed >= 0 ? Math.floor(parsed) : 120_000;
+    db.exec(`PRAGMA busy_timeout = ${busyTimeoutMs}`);
+    enableWal(db, busyTimeoutMs);
+    return db;
+}
+/** Open an existing database without changing journal mode, schema, or user data. */
+export function openReadOnlyDatabase(path) {
+    const options = isBun
+        ? { readonly: true, create: false }
+        : { readonly: true, fileMustExist: true };
+    const db = new _Database(path, options);
+    const raw = process.env.QMD_SQLITE_BUSY_TIMEOUT;
+    const parsed = raw !== undefined && raw !== "" ? Number(raw) : Number.NaN;
+    const busyTimeoutMs = Number.isFinite(parsed) && parsed >= 0 ? Math.floor(parsed) : 120_000;
+    db.exec(`PRAGMA busy_timeout = ${busyTimeoutMs}`);
+    return db;
+}
+/**
+ * Load the sqlite-vec extension into a database.
+ *
+ * Throws with platform-specific fix instructions when the extension is
+ * unavailable.
+ */
+export function loadSqliteVec(db) {
+    if (!_sqliteVecLoad) {
+        const hint = isBun && process.platform === "darwin"
+            ? "On macOS with Bun, install Homebrew SQLite: brew install sqlite\n" +
+                "Or install qmd with npm instead: npm install -g @wei840222/qmd"
+            : "Ensure the sqlite-vec native module is installed correctly.";
+        throw new Error(`sqlite-vec extension is unavailable. ${hint}`);
+    }
+    _sqliteVecLoad(db);
+}

package/dist/diagnostics.d.ts

@@ -0,0 +1,62 @@
+import type { Database } from "./db.js";
+import type { EmbeddingProvider } from "./embedding/provider.js";
+export type DiagnosticReadiness = "missing" | "ready" | "stale" | "partial" | "inconsistent" | "incompatible";
+export interface EmbeddingDiagnostics {
+    provider: {
+        id: string | null;
+        remote: boolean;
+        model: string;
+        dimension: number | null;
+        keyConfigured: boolean;
+    };
+    identity: {
+        shortFingerprint: string | null;
+        fullFingerprint: string | null;
+        storedShortFingerprint: string | null;
+        storedFullFingerprint: string | null;
+        compatible: boolean;
+    };
+    build: {
+        state: "missing" | "empty" | "building" | "ready" | "partial" | "incompatible";
+        generation: number | null;
+        leaseExpiresAt: number | null;
+    };
+    chunks: {
+        pendingDocuments: number;
+        metadataOnly: number;
+        vectorOnly: number;
+        incompleteLayouts: number;
+    };
+    repairCommand: string | null;
+}
+export interface LexicalDiagnostics {
+    jiebaCapability: "unknown" | "available" | "unavailable";
+    analyzerFingerprint: string;
+    storedAnalyzerFingerprint: string | null;
+    state: "missing" | "empty" | "building" | "ready" | "unavailable" | "dirty";
+    channels: {
+        char: DiagnosticReadiness;
+        word: DiagnosticReadiness;
+        bigram: DiagnosticReadiness;
+    };
+    dirtySinceMutationSeq: number | null;
+    rebuildReason: string | null;
+    repairCommand: string | null;
+}
+export interface IndexDiagnostics {
+    embedding: EmbeddingDiagnostics;
+    lexical: LexicalDiagnostics;
+}
+export interface ConfiguredEmbeddingProviderDiagnostics {
+    id: string;
+    remote: boolean;
+    model: string;
+    dimension: number | null;
+}
+export declare function inspectIndexDiagnostics(db: Database, options: {
+    fallbackModel: string;
+    provider?: EmbeddingProvider;
+    keyConfigured?: boolean;
+    configuredProvider?: ConfiguredEmbeddingProviderDiagnostics;
+}): IndexDiagnostics;
+export declare function diagnosticsSnapshotHash(diagnostics: IndexDiagnostics): string;