ctxman 3.0.0 → 3.1.0

package/lib/pr/related-tests.js

@@ -0,0 +1,296 @@
+/**
+ * Find the test files related to a set of changed files: by file name (foo.js ↔
+ * foo.test.js, test_foo.py, foo_test.go, FooTest.java, __tests__/foo.js), by package (Go
+ * tests in the same directory), by imports of the changed modules (JavaScript/TypeScript
+ * through ImportTracker, Python `import`/`from`), and by references to changed class or
+ * method names
+ */
+
+import path from 'path';
+import { ImportTracker } from '../analyzers/import-tracker.js';
+import { supportsMethods } from './method-mapper.js';
+
+const posix = path.posix;
+
+const TEST_DIR = /(^|\/)(__tests__|__test__|tests?|specs?)\//i;
+const NON_TEST_DIR = /(^|\/)(__fixtures__|fixtures?|__snapshots__|__mocks__|testdata)\//i;
+const GENERIC_STEMS = new Set(['index', '__init__', 'main', 'mod', 'lib', 'init']);
+const JS_EXTENSIONS = ['.js', '.ts', '.mjs', '.cjs', '.jsx', '.tsx', '.mts', '.cts'];
+const JS_FILE = /\.(m|c)?(j|t)sx?$/i;
+const CLASS_LANGUAGES = /\.(java|kt|kts|scala|cs|swift|php|groovy)$/i;
+
+// Names too common to say anything when a test mentions them
+const COMMON_NAMES = new Set(
+  (
+    'constructor init main run get set test setup setUp tearDown toString render handle ' +
+    'execute call apply process update create delete remove start stop close open load ' +
+    'save read write value index length size name then catch describe expect before ' +
+    'after beforeEach afterEach beforeAll afterAll __init__ __str__ __repr__ __eq__ equals ' +
+    'hashCode error parse format build reset clear next done send emit async await'
+  ).split(' ')
+);
+
+const importTracker = new ImportTracker('.');
+
+/**
+ * Whether a path looks like a test source file
+ * @param {string} filePath - Repository-relative, forward slashes
+ * @returns {boolean}
+ */
+export function isTestFile(filePath) {
+  if (!supportsMethods(filePath) || NON_TEST_DIR.test(filePath)) return false;
+  const base = posix.basename(filePath);
+  return (
+    /[._-](test|spec)s?\.[^.]+$/i.test(base) ||
+    /^test_.+\.py$/i.test(base) ||
+    /[a-z0-9](Tests?|Spec|IT)\.[^.]+$/.test(base) ||
+    TEST_DIR.test(filePath)
+  );
+}
+
+const normalize = (stem) => stem.toLowerCase().replace(/[-_.]/g, '');
+
+/** Directory name to use for generic file names such as index.js or __init__.py */
+function parentName(filePath) {
+  const parts = posix.dirname(filePath).split('/');
+  for (let i = parts.length - 1; i >= 0; i--) {
+    if (parts[i] && parts[i] !== '.' && !/^(__tests__|__test__|tests?|specs?)$/i.test(parts[i])) {
+      return parts[i];
+    }
+  }
+  return '';
+}
+
+/**
+ * Name a source file is known by, for matching against test names
+ * @param {string} filePath
+ */
+export function sourceStem(filePath) {
+  const stem = posix.basename(filePath).replace(/\.[^.]+$/, '');
+  return normalize(GENERIC_STEMS.has(stem.toLowerCase()) ? parentName(filePath) : stem);
+}
+
+/**
+ * Name of the source file a test is named after (foo.test.js → foo, FooTest.java → foo)
+ * @param {string} filePath
+ */
+export function testStem(filePath) {
+  let stem = posix.basename(filePath).replace(/\.[^.]+$/, '');
+  stem = stem
+    .replace(/[._-](test|spec)s?$/i, '')
+    .replace(/^test_/i, '')
+    .replace(/([a-z0-9])(Tests?|Spec|IT)$/, '$1');
+  if (!stem || GENERIC_STEMS.has(stem.toLowerCase())) stem = parentName(filePath);
+  return normalize(stem);
+}
+
+/** Repository-relative module paths a JavaScript/TypeScript test imports */
+function jsImports(testPath, content) {
+  const specifiers = [
+    ...importTracker.parseES6Imports(content),
+    ...importTracker.parseCommonJSImports(content),
+  ].map((imp) => imp.package);
+  // Side-effect imports and module mocks, which ImportTracker does not report
+  const extra = /(?:\bimport\s+|\b(?:vi|jest)\.(?:mock|doMock)\s*\(\s*)['"]([^'"]+)['"]/g;
+  let match;
+  while ((match = extra.exec(content)) !== null) specifiers.push(match[1]);
+
+  const dir = posix.dirname(testPath);
+  const resolved = new Set();
+  for (const specifier of specifiers) {
+    if (!specifier.startsWith('.')) continue;
+    const base = posix.normalize(posix.join(dir, specifier));
+    const stripped = base.replace(JS_FILE, '');
+    resolved.add(base);
+    for (const ext of JS_EXTENSIONS) {
+      resolved.add(base + ext);
+      resolved.add(`${base}/index${ext}`);
+      resolved.add(stripped + ext);
+    }
+  }
+  return resolved;
+}
+
+/** Path suffixes (pkg/mod.py, pkg/mod/__init__.py) of the modules a Python test imports */
+function pythonImports(testPath, content) {
+  const modules = [];
+  const pattern =
+    /^[ \t]*(?:from[ \t]+([.\w]+)[ \t]+import[ \t]+\(?([\w*, \t]+)|import[ \t]+([\w., \t]+))/gm;
+  let match;
+  while ((match = pattern.exec(content)) !== null) {
+    if (match[1]) {
+      modules.push(match[1]);
+      for (const name of match[2].split(',')) {
+        const clean = name.trim().split(/\s+/)[0];
+        if (clean && clean !== '*')
+          modules.push(`${match[1]}${match[1].endsWith('.') ? '' : '.'}${clean}`);
+      }
+    } else {
+      for (const name of match[3].split(',')) modules.push(name.trim().split(/\s+/)[0]);
+    }
+  }
+
+  const suffixes = [];
+  for (const moduleName of modules) {
+    if (!moduleName) continue;
+    const dots = /^\.*/.exec(moduleName)[0].length;
+    const rest = moduleName.slice(dots).split('.').filter(Boolean).join('/');
+    if (!rest) continue;
+    let base = rest;
+    if (dots > 0) {
+      let dir = posix.dirname(testPath);
+      for (let i = 1; i < dots; i++) dir = posix.dirname(dir);
+      base = posix.normalize(posix.join(dir, rest));
+      if (base.startsWith('..')) continue;
+      suffixes.push(
+        { path: `${base}.py`, exact: true },
+        { path: `${base}/__init__.py`, exact: true }
+      );
+    } else {
+      suffixes.push(
+        { path: `${base}.py`, exact: false },
+        { path: `${base}/__init__.py`, exact: false }
+      );
+    }
+  }
+  return suffixes;
+}
+
+const escapeRegex = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+/**
+ * Names that `content` mentions as whole identifiers (`call` set: only when called, as in
+ * `name(`, which keeps out variables and properties that share a method's name)
+ */
+function referencedNames(content, names, { call = false } = {}) {
+  if (names.length === 0) return [];
+  const after = call ? '\\s*\\(' : '(?![\\w$])';
+  const pattern = new RegExp(`(?<![\\w$])(${names.map(escapeRegex).join('|')})${after}`, 'g');
+  const found = new Set();
+  let match;
+  while ((match = pattern.exec(content)) !== null) found.add(match[1]);
+  return [...found];
+}
+
+/**
+ * @typedef {object} RelatedTest
+ * @property {string} path
+ * @property {string[]} reasons
+ * @property {boolean} changed - The test itself is part of the change
+ */
+
+/**
+ * Test files related to a change
+ * @param {object} params
+ * @param {string[]} params.candidates - Every file of the head version (repository-relative)
+ * @param {Array<{path: string, oldPath: string|null, status: string}>} params.changedFiles
+ * @param {string[]} [params.methodNames] - Names of changed and deleted methods
+ * @param {(paths: string[]) => Map<string, string|null>} params.readContents - Head contents
+ * @param {number} [params.maxScan=3000] - Read at most this many test files for imports
+ *   and references (beyond it only names are compared)
+ * @returns {RelatedTest[]} Strongest matches first
+ */
+export function findRelatedTests({
+  candidates,
+  changedFiles,
+  methodNames = [],
+  readContents,
+  maxScan = 3000,
+}) {
+  const tests = candidates.filter(isTestFile);
+  const changedTests = new Set(changedFiles.filter((f) => f.status !== 'D').map((f) => f.path));
+  const sources = changedFiles.filter((f) => !isTestFile(f.path));
+  const sourcePaths = new Set();
+  for (const file of sources) {
+    sourcePaths.add(file.path);
+    if (file.oldPath) sourcePaths.add(file.oldPath);
+  }
+
+  const byStem = new Map();
+  for (const sourcePath of sourcePaths) {
+    const stem = sourceStem(sourcePath);
+    if (!stem) continue;
+    if (!byStem.has(stem)) byStem.set(stem, []);
+    byStem.get(stem).push(sourcePath);
+  }
+  const goDirs = new Map();
+  for (const sourcePath of sourcePaths) {
+    if (sourcePath.endsWith('.go')) goDirs.set(posix.dirname(sourcePath), sourcePath);
+  }
+  const classNames = [...sourcePaths]
+    .filter((p) => CLASS_LANGUAGES.test(p))
+    .map((p) => posix.basename(p).replace(/\.[^.]+$/, ''))
+    .filter((name) => /^[A-Z]\w{3,}$/.test(name));
+  const names = [
+    ...new Set(
+      methodNames
+        .map((name) => name.split(/\s+/).pop())
+        .filter((name) => name && name.length >= 4 && !COMMON_NAMES.has(name))
+    ),
+  ];
+
+  const found = new Map();
+  const add = (testPath, reason, weight) => {
+    if (!found.has(testPath)) found.set(testPath, { path: testPath, reasons: [], score: 0 });
+    const entry = found.get(testPath);
+    if (!entry.reasons.includes(reason)) {
+      entry.reasons.push(reason);
+      entry.score += weight;
+    }
+  };
+
+  for (const testPath of tests) {
+    if (changedTests.has(testPath)) add(testPath, 'changed in this diff', 3);
+    for (const sourcePath of byStem.get(testStem(testPath)) || []) {
+      add(testPath, `named after ${sourcePath}`, 3);
+    }
+    if (testPath.endsWith('_test.go') && goDirs.has(posix.dirname(testPath))) {
+      add(testPath, `same Go package as ${goDirs.get(posix.dirname(testPath))}`, 2);
+    }
+  }
+
+  if (sourcePaths.size > 0 && tests.length <= maxScan) {
+    const contents = readContents(tests);
+    const callers = new Map();
+    for (const testPath of tests) {
+      const content = contents.get(testPath);
+      if (!content) continue;
+      if (JS_FILE.test(testPath)) {
+        const imported = jsImports(testPath, content);
+        for (const sourcePath of sourcePaths) {
+          if (imported.has(sourcePath)) add(testPath, `imports ${sourcePath}`, 3);
+        }
+      } else if (testPath.endsWith('.py')) {
+        for (const suffix of pythonImports(testPath, content)) {
+          for (const sourcePath of sourcePaths) {
+            const matches = suffix.exact
+              ? sourcePath === suffix.path
+              : sourcePath === suffix.path || sourcePath.endsWith(`/${suffix.path}`);
+            if (matches) add(testPath, `imports ${sourcePath}`, 3);
+          }
+        }
+      }
+      for (const name of referencedNames(content, classNames)) {
+        add(testPath, `references ${name}`, 2);
+      }
+      for (const name of referencedNames(content, names, { call: true })) {
+        if (!callers.has(name)) callers.set(name, []);
+        callers.get(name).push(testPath);
+      }
+    }
+    // A name that many tests call (a common helper name) says nothing about this change
+    const common = Math.max(10, tests.length * 0.1);
+    for (const [name, testPaths] of callers) {
+      if (testPaths.length > common) continue;
+      for (const testPath of testPaths) add(testPath, `calls ${name}()`, 1);
+    }
+  }
+
+  return [...found.values()]
+    .sort((a, b) => b.score - a.score || a.path.localeCompare(b.path))
+    .map(({ path: testPath, reasons }) => ({
+      path: testPath,
+      reasons,
+      changed: changedTests.has(testPath),
+    }));
+}

package/lib/rag/DataSourcePlugin.js

@@ -11,21 +11,21 @@ export class DataSourcePlugin {
 
   /**
    * Validates if the necessary configuration (tokens, urls) is present.
-   * @param {Object} config 
+   * @param {Object} config
    * @returns {Promise<boolean>}
    */
-  async validateConfig(config) {
+  async validateConfig(_config) {
     return true;
   }
 
   /**
    * Collects data from the source.
    * Generator function that yields documents to be indexed.
-   * 
-   * @param {Object} options 
+   *
+   * @param {Object} options
    * @yields {import('./Indexer').IndexableDocument}
    */
-  async *collect(options = {}) {
+  async *collect(_options = {}) {
     throw new Error('Not implemented');
   }
 }

package/lib/rag/EmbeddingProvider.js

@@ -1,15 +1,13 @@
-import { pipeline } from '@xenova/transformers';
-
 /**
  * Abstract base class for embedding providers
  */
 export class EmbeddingProvider {
   /**
    * Generates an embedding for the given text.
-   * @param {string} text 
+   * @param {string} text
    * @returns {Promise<number[]>}
    */
-  async embed(text) {
+  async embed(_text) {
     throw new Error('Not implemented');
   }
 }
@@ -27,8 +25,21 @@ export class TransformersEmbeddingProvider extends EmbeddingProvider {
 
   async init() {
     if (!this.pipe) {
+      // Optional dependency: only `ctxman ask` needs it, so load it on first use
+      let transformers;
+      try {
+        transformers = await import('@xenova/transformers');
+      } catch (error) {
+        if (error.code === 'ERR_MODULE_NOT_FOUND') {
+          throw new Error(
+            'Please install @xenova/transformers to use TransformersEmbeddingProvider (ctxman ask): npm install @xenova/transformers'
+          );
+        }
+        throw error;
+      }
+
       // Load the pipeline. This will download the model if not present.
-      this.pipe = await pipeline('feature-extraction', this.modelName);
+      this.pipe = await transformers.pipeline('feature-extraction', this.modelName);
     }
   }
 
@@ -57,10 +68,10 @@ export class MockEmbeddingProvider extends EmbeddingProvider {
     // Let's make it pseudo-random based on text hash to be stable.
     let hash = 0;
     for (let i = 0; i < text.length; i++) {
-      hash = ((hash << 5) - hash) + text.charCodeAt(i);
+      hash = (hash << 5) - hash + text.charCodeAt(i);
       hash |= 0;
     }
-    
+
     const vector = [];
     for (let i = 0; i < this.dimension; i++) {
       // Simple pseudo-random generator
@@ -70,6 +81,6 @@ export class MockEmbeddingProvider extends EmbeddingProvider {
 
     // Normalize
     const norm = Math.sqrt(vector.reduce((sum, val) => sum + val * val, 0));
-    return vector.map(val => val / norm);
+    return vector.map((val) => val / norm);
   }
 }

package/lib/rag/Indexer.js

@@ -11,7 +11,7 @@ const logger = getLogger('Indexer');
 
 export class Indexer {
   /**
-   * @param {import('./stores/BaseVectorStore').BaseVectorStore} vectorStore 
+   * @param {import('./stores/BaseVectorStore').BaseVectorStore} vectorStore
    */
   constructor(vectorStore) {
     this.vectorStore = vectorStore;
@@ -20,7 +20,7 @@ export class Indexer {
 
   /**
    * Register a data source plugin
-   * @param {import('./DataSourcePlugin').DataSourcePlugin} sourcePlugin 
+   * @param {import('./DataSourcePlugin').DataSourcePlugin} sourcePlugin
    */
   registerSource(sourcePlugin) {
     this.sources.set(sourcePlugin.name, sourcePlugin);
@@ -31,9 +31,10 @@ export class Indexer {
    * Run indexing for a specific source or all sources
    * @param {string} [sourceName] - Optional source name to run specific indexer
    * @param {Object} options - Options passed to collect method
+   * @throws {Error} When a source fails, after the remaining sources have been indexed
    */
   async index(sourceName, options = {}) {
-    const sourcesToRun = sourceName 
+    const sourcesToRun = sourceName
       ? [this.sources.get(sourceName)].filter(Boolean)
       : Array.from(this.sources.values());
 
@@ -42,6 +43,7 @@ export class Indexer {
       return;
     }
 
+    const failures = [];
     for (const source of sourcesToRun) {
       logger.info(`Starting indexing for source: ${source.name}`);
       let count = 0;
@@ -56,8 +58,8 @@ export class Indexer {
               ...doc.metadata,
               sourceId: doc.id,
               source: source.name,
-              indexedAt: new Date().toISOString()
-            }
+              indexedAt: new Date().toISOString(),
+            },
           });
 
           if (batch.length >= BATCH_SIZE) {
@@ -77,7 +79,14 @@ export class Indexer {
         logger.info(`Completed indexing ${source.name}. Total documents: ${count}`);
       } catch (error) {
         logger.error(`Error indexing ${source.name}: ${error.message}`);
+        failures.push(`${source.name}: ${error.message}`);
       }
     }
+
+    // Callers must not treat a failed source (e.g. the embedding model could not be
+    // loaded) as an empty but successful index
+    if (failures.length > 0) {
+      throw new Error(`Indexing failed for ${failures.join('; ')}`);
+    }
   }
 }

package/lib/rag/VectorStoreFactory.js

@@ -4,9 +4,9 @@ import { PineconeStore } from './stores/PineconeStore.js';
 
 export class VectorStoreFactory {
   /**
-   * @param {string} type 
-   * @param {import('./EmbeddingProvider').EmbeddingProvider} embeddingProvider 
-   * @param {Object} config 
+   * @param {string} type
+   * @param {import('./EmbeddingProvider').EmbeddingProvider} embeddingProvider
+   * @param {Object} config
    */
   static create(type, embeddingProvider, config = {}) {
     switch (type.toLowerCase()) {

package/lib/rag/sources/FileDataSource.js

@@ -36,8 +36,8 @@ export class FileDataSource extends DataSourcePlugin {
 
     for (const entry of entries) {
       const fullPath = path.join(dir, entry.name);
-      
-      if (exclude.some(ex => fullPath.includes(ex))) continue;
+
+      if (exclude.some((ex) => fullPath.includes(ex))) continue;
 
       if (entry.isDirectory()) {
         yield* this.walkDirectory(fullPath, depth - 1, include, exclude);
@@ -48,7 +48,7 @@ export class FileDataSource extends DataSourcePlugin {
         try {
           const content = await fs.readFile(fullPath, 'utf-8');
           // Basic text check (skip binaries)
-          if (content.includes('\0')) continue; 
+          if (content.includes('\0')) continue;
 
           yield {
             id: fullPath,
@@ -58,11 +58,11 @@ export class FileDataSource extends DataSourcePlugin {
               path: fullPath,
               extension: ext,
               filename: entry.name,
-              size: content.length
-            }
+              size: content.length,
+            },
           };
         } catch (error) {
-           console.warn(`[FileDataSource] Failed to read ${fullPath}: ${error.message}`);
+          console.warn(`[FileDataSource] Failed to read ${fullPath}: ${error.message}`);
         }
       }
     }

package/lib/rag/stores/BaseVectorStore.js

@@ -26,18 +26,18 @@ export class BaseVectorStore {
   }
 
   /**
-   * @param {Array<{text: string, metadata: Object}>} docs 
+   * @param {Array<{text: string, metadata: Object}>} docs
    */
-  async addDocuments(docs) {
+  async addDocuments(_docs) {
     throw new Error('Method not implemented');
   }
 
   /**
-   * @param {string} queryText 
-   * @param {number} limit 
+   * @param {string} queryText
+   * @param {number} limit
    * @returns {Promise<Array<SearchResult>>}
    */
-  async search(queryText, limit = 5) {
+  async search(queryText, _limit = 5) {
     throw new Error('Method not implemented');
   }
 }

package/lib/rag/stores/ChromaDBStore.js

@@ -21,7 +21,7 @@ export class ChromaDBStore extends BaseVectorStore {
     try {
       const { ChromaClient } = await import('chromadb');
       this.client = new ChromaClient({ path: this.url });
-      
+
       this.collection = await this.client.getOrCreateCollection({
         name: this.collectionName,
       });
@@ -37,22 +37,22 @@ export class ChromaDBStore extends BaseVectorStore {
     if (!this.collection) await this.init();
     if (docs.length === 0) return;
 
-    const ids = docs.map(d => d.id || crypto.randomUUID());
-    const metadatas = docs.map(d => d.metadata || {});
-    const documents = docs.map(d => d.text);
-    
+    const ids = docs.map((d) => d.id || crypto.randomUUID());
+    const metadatas = docs.map((d) => d.metadata || {});
+    const documents = docs.map((d) => d.text);
+
     // Chroma can handle embeddings, but we have a provider.
     // If we want to use our provider:
     const embeddings = [];
     for (const doc of docs) {
-        embeddings.push(await this.embeddingProvider.embed(doc.text));
+      embeddings.push(await this.embeddingProvider.embed(doc.text));
     }
 
     await this.collection.add({
       ids,
       embeddings,
       metadatas,
-      documents
+      documents,
     });
   }
 
@@ -63,7 +63,7 @@ export class ChromaDBStore extends BaseVectorStore {
 
     const results = await this.collection.query({
       queryEmbeddings: [queryEmbedding],
-      nResults: limit
+      nResults: limit,
     });
 
     // Chroma returns arrays of arrays
@@ -71,12 +71,12 @@ export class ChromaDBStore extends BaseVectorStore {
 
     const hits = [];
     const count = results.ids[0].length;
-    
+
     for (let i = 0; i < count; i++) {
       hits.push({
         text: results.documents[0][i],
         score: results.distances ? results.distances[0][i] : 0,
-        metadata: results.metadatas[0][i]
+        metadata: results.metadatas[0][i],
       });
     }
 

package/lib/rag/stores/LanceDBStore.js

@@ -1,4 +1,3 @@
-import * as lancedb from '@lancedb/lancedb';
 import fs from 'fs/promises';
 import { BaseVectorStore } from './BaseVectorStore.js';
 
@@ -19,11 +18,24 @@ export class LanceDBStore extends BaseVectorStore {
   async init() {
     if (this.initialized) return;
 
+    // Optional dependency: only `ctxman ask` needs it, so load it on first use
+    let lancedb;
+    try {
+      lancedb = await import('@lancedb/lancedb');
+    } catch (error) {
+      if (error.code === 'ERR_MODULE_NOT_FOUND') {
+        throw new Error(
+          'Please install @lancedb/lancedb to use LanceDBStore (ctxman ask): npm install @lancedb/lancedb'
+        );
+      }
+      throw error;
+    }
+
     // Ensure directory exists
     await fs.mkdir(this.storagePath, { recursive: true });
 
     this.db = await lancedb.connect(this.storagePath);
-    
+
     const tableNames = await this.db.tableNames();
     if (tableNames.includes(this.tableName)) {
       this.table = await this.db.openTable(this.tableName);
@@ -34,8 +46,8 @@ export class LanceDBStore extends BaseVectorStore {
 
   /**
    * Adds a single document to the store.
-   * @param {string} text 
-   * @param {Object} metadata 
+   * @param {string} text
+   * @param {Object} metadata
    */
   async addDocument(text, metadata = {}) {
     return this.addDocuments([{ text, metadata }]);
@@ -43,7 +55,7 @@ export class LanceDBStore extends BaseVectorStore {
 
   /**
    * Adds multiple documents to the store.
-   * @param {Array<{text: string, metadata: Object}>} docs 
+   * @param {Array<{text: string, metadata: Object}>} docs
    */
   async addDocuments(docs) {
     if (docs.length === 0) return;
@@ -57,7 +69,7 @@ export class LanceDBStore extends BaseVectorStore {
         text: doc.text,
         id: crypto.randomUUID(),
         timestamp: Date.now(),
-        ...doc.metadata
+        ...doc.metadata,
       });
     }
 
@@ -71,8 +83,8 @@ export class LanceDBStore extends BaseVectorStore {
 
   /**
    * Semantic search for documents.
-   * @param {string} queryText 
-   * @param {number} limit 
+   * @param {string} queryText
+   * @param {number} limit
    * @returns {Promise<Array<{text: string, score: number, metadata: Object}>>}
    */
   async search(queryText, limit = 5) {
@@ -80,19 +92,17 @@ export class LanceDBStore extends BaseVectorStore {
     if (!this.table) return [];
 
     const queryVector = await this.embeddingProvider.embed(queryText);
-    
+
     // LanceDB returns _distance by default (L2 distance usually).
     // Lower is better.
-    const results = await this.table.search(queryVector)
-      .limit(limit)
-      .toArray();
+    const results = await this.table.search(queryVector).limit(limit).toArray();
 
-    return results.map(row => {
-      const { vector, text, _distance, ...metadata } = row;
+    return results.map((row) => {
+      const { vector: _vector, text, _distance, ...metadata } = row;
       return {
         text,
         score: _distance,
-        metadata
+        metadata,
       };
     });
   }
@@ -100,10 +110,10 @@ export class LanceDBStore extends BaseVectorStore {
   async deleteTable() {
     if (!this.initialized) await this.init();
     try {
-        await this.db.dropTable(this.tableName);
-        this.table = null;
-    } catch (e) {
-        // Ignore if not exists
+      await this.db.dropTable(this.tableName);
+      this.table = null;
+    } catch (_e) {
+      // Ignore if not exists
     }
   }
 }