ctxman 3.0.0 → 3.1.1

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/ask.js

@@ -0,0 +1,122 @@
+/**
+ * Semantic search over a project (`ctxman ask` and the MCP `ask_codebase` tool): an
+ * embedding index under .ctxman/self-knowledge, built on first use, then the snippets
+ * closest to the question. Needs the optional @xenova/transformers and @lancedb/lancedb
+ * packages; the embedding model is downloaded on first use.
+ *
+ * Files left out by .gitignore, .contextignore, .contextinclude or the export policy are
+ * not indexed, and results from an older index are checked against the policy again.
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { Scanner } from '../core/Scanner.js';
+import { redactSecrets } from '../utils/secret-redactor.js';
+import { VectorStoreFactory } from './VectorStoreFactory.js';
+import { TransformersEmbeddingProvider } from './EmbeddingProvider.js';
+import { Indexer } from './Indexer.js';
+import { FileDataSource } from './sources/FileDataSource.js';
+
+export const ASK_STORE_DIR = path.join('.ctxman', 'self-knowledge');
+export const DEFAULT_ASK_LIMIT = 5;
+
+const INCLUDE = ['.js', '.md', '.ts', '.json'];
+const EXCLUDE = ['node_modules', '.git', 'dist', 'coverage', '.ctxman'];
+// Extra rows asked of the store, so results the policy removes still leave `limit`
+const OVERFETCH = 10;
+
+async function hasIndex(storePath) {
+  try {
+    return (await fs.readdir(storePath)).length > 0;
+  } catch {
+    return false;
+  }
+}
+
+const toPosix = (p) => p.split(path.sep).join('/');
+
+/**
+ * @param {string} root - Project directory
+ * @param {string} query - The question
+ * @param {Object} [options]
+ * @param {number} [options.limit=5] - Snippets to return
+ * @param {boolean} [options.redact=true] - Redact secrets in the snippets
+ * @param {number} [options.maxChars] - Cut each snippet to this many characters
+ * @param {(event: 'indexing'|'indexed') => void} [options.onProgress]
+ * @param {(storePath: string) => object} [options.createStore] - Vector store factory
+ *   (tests); default: LanceDB with the local embedding model
+ * @returns {Promise<{query: string, indexed: boolean, results: Array<{file: string,
+ *   score: number|null, text: string, truncated: boolean}>, removedByPolicy: number,
+ *   redactions: number}>}
+ * @throws {Error} When the question is empty, the policy is invalid, the optional packages
+ *   are missing or indexing fails
+ */
+export async function askCodebase(root, query, options = {}) {
+  const question = typeof query === 'string' ? query.trim() : '';
+  if (!question) throw new Error('A question is required');
+  const limit =
+    Number.isInteger(options.limit) && options.limit > 0 ? options.limit : DEFAULT_ASK_LIMIT;
+  const projectRoot = path.resolve(root);
+  const storePath = path.join(projectRoot, ASK_STORE_DIR);
+  const onProgress = options.onProgress || (() => {});
+
+  const scanner = new Scanner(projectRoot);
+  // Load now: an invalid policy fails the command instead of being skipped
+  scanner.getPolicy();
+  const relative = (fullPath) => toPosix(path.relative(projectRoot, fullPath));
+  const left = (fullPath) => {
+    const rel = relative(fullPath);
+    return rel.startsWith('../') || path.isAbsolute(rel);
+  };
+
+  const store = options.createStore
+    ? options.createStore(storePath)
+    : VectorStoreFactory.create('lancedb', new TransformersEmbeddingProvider(), {
+        path: storePath,
+      });
+
+  let indexed = false;
+  if (!(await hasIndex(storePath))) {
+    onProgress('indexing');
+    const indexer = new Indexer(store);
+    indexer.registerSource(new FileDataSource());
+    await indexer.index('local-files', {
+      targetDir: projectRoot,
+      include: INCLUDE,
+      exclude: EXCLUDE,
+      skip: (fullPath) =>
+        scanner.shouldIgnore(path.relative(projectRoot, fullPath), fullPath) ||
+        scanner.isDenied(relative(fullPath)),
+    });
+    indexed = true;
+    onProgress('indexed');
+  }
+
+  const rows = await store.search(question, limit + OVERFETCH);
+  const results = [];
+  let removedByPolicy = 0;
+  let redactions = 0;
+  for (const row of rows) {
+    const fullPath = row.metadata?.path;
+    if (typeof fullPath !== 'string' || left(fullPath)) continue;
+    const file = relative(fullPath);
+    if (scanner.isDenied(file)) {
+      removedByPolicy++;
+      continue;
+    }
+    if (results.length === limit) continue;
+    let text = String(row.text ?? '');
+    if (options.redact !== false) {
+      const redacted = redactSecrets(text);
+      text = redacted.text;
+      redactions += redacted.findings.length;
+    }
+    const truncated = Boolean(options.maxChars) && text.length > options.maxChars;
+    if (truncated) text = text.slice(0, options.maxChars);
+    results.push({ file, score: row.score ?? null, text, truncated });
+  }
+
+  return { query: question, indexed, results, removedByPolicy, redactions };
+}
+
+export default askCodebase;

package/lib/rag/sources/FileDataSource.js

@@ -19,11 +19,13 @@ export class FileDataSource extends DataSourcePlugin {
     const maxDepth = options.maxDepth || 5;
     const include = options.include || ['.js', '.md', '.ts', '.json'];
     const exclude = options.exclude || ['node_modules', '.git', 'dist', 'coverage'];
+    // (fullPath, isDirectory) => true leaves a file or directory out
+    const skip = options.skip || (() => false);
 
-    yield* this.walkDirectory(targetDir, maxDepth, include, exclude);
+    yield* this.walkDirectory(targetDir, maxDepth, include, exclude, skip);
   }
 
-  async *walkDirectory(dir, depth, include, exclude) {
+  async *walkDirectory(dir, depth, include, exclude, skip = () => false) {
     if (depth < 0) return;
 
     let entries;
@@ -36,11 +38,12 @@ 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 (skip(fullPath, entry.isDirectory())) continue;
 
       if (entry.isDirectory()) {
-        yield* this.walkDirectory(fullPath, depth - 1, include, exclude);
+        yield* this.walkDirectory(fullPath, depth - 1, include, exclude, skip);
       } else if (entry.isFile()) {
         const ext = path.extname(entry.name);
         if (include.length > 0 && !include.includes(ext)) continue;
@@ -48,7 +51,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 +61,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');
   }
 }