@softerist/heuristic-mcp 2.1.47 → 3.0.0

package/lib/config.js

@@ -1,92 +1,327 @@
-import fs from "fs/promises";
-import path from "path";
-import os from "os";
-import crypto from "crypto";
-import { fileURLToPath } from "url";
-import { ProjectDetector } from "./project-detector.js";
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+import { fileURLToPath } from 'url';
+import { ProjectDetector } from './project-detector.js';
 
 const DEFAULT_CONFIG = {
-  searchDirectory: ".",
+  searchDirectory: '.',
   fileExtensions: [
     // JavaScript/TypeScript
-    "js", "ts", "jsx", "tsx", "mjs", "cjs",
+    'js',
+    'ts',
+    'jsx',
+    'tsx',
+    'mjs',
+    'cjs',
+    'mts',
+    'cts',
     // Styles
-    "css", "scss", "sass", "less", "styl",
+    'css',
+    'scss',
+    'sass',
+    'less',
+    'styl',
+    'stylus',
+    'postcss',
+    // Web Frameworks
+    'vue',
+    'svelte',
+    'astro',
     // Markup
-    "html", "htm", "xml", "svg",
+    'html',
+    'htm',
+    'xml',
+    'svg',
+    'xhtml',
+    'pug',
+    'jade',
+    // Templating
+    'handlebars',
+    'hbs',
+    'mustache',
+    'ejs',
+    'njk',
+    'liquid',
     // Python
-    "py", "pyw", "pyx",
-    // Java/Kotlin/Scala
-    "java", "kt", "kts", "scala",
-    // C/C++
-    "c", "cpp", "cc", "cxx", "h", "hpp", "hxx",
-    // C#
-    "cs", "csx",
-    // Go
-    "go",
-    // Rust
-    "rs",
+    'py',
+    'pyw',
+    'pyx',
+    'pxd',
+    'pxi',
+    'ipynb',
+    // Java/JVM
+    'java',
+    'kt',
+    'kts',
+    'groovy',
+    'gvy',
+    'gradle',
+    'scala',
+    'sbt',
+    'clj',
+    'cljs',
+    'cljc',
+    'edn',
+    // C/C++ family
+    'c',
+    'cpp',
+    'cc',
+    'cxx',
+    'h',
+    'hpp',
+    'hxx',
+    'h++',
+    'm',
+    'mm',
+    // .NET
+    'cs',
+    'csx',
+    'vb',
+    'vbs',
+    'fs',
+    'fsx',
+    'fsi',
+    // System
+    'go',
+    'rs',
+    'rlib',
+    'swift',
     // Ruby
-    "rb", "rake",
+    'rb',
+    'erb',
+    'rake',
+    'gemspec',
     // PHP
-    "php", "phtml",
-    // Swift
-    "swift",
-    // Shell scripts
-    "sh", "bash", "zsh", "fish",
-    // Config & Data
-    "json", "yaml", "yml", "toml", "ini", "env",
-    // Documentation
-    "md", "mdx", "txt", "rst",
+    'php',
+    'phtml',
+    'php3',
+    'php4',
+    'php5',
+    'phps',
+    // Neural/AI/Data
+    'r',
+    'rmd',
+    'jl',
+    // Shell/Config
+    'sh',
+    'bash',
+    'zsh',
+    'fish',
+    'ksh',
+    'csh',
+    'tcsh',
+    'bat',
+    'cmd',
+    'ps1',
+    'psm1',
+    'json',
+    'json5',
+    'jsonc',
+    'yaml',
+    'yml',
+    'toml',
+    'ini',
+    'cfg',
+    'conf',
+    'properties',
+    'env',
+    'dockerfile',
+    'containerfile',
+    'makefile',
+    'mk',
+    'cmake',
+    'jenkinsfile',
+    'vagrantfile',
     // Database
-    "sql",
-    // Other
-    "r", "R", "lua", "vim", "pl", "pm"
+    'sql',
+    'pgsql',
+    'mysql',
+    'sqlite',
+    // Docs
+    'md',
+    'markdown',
+    'mdx',
+    'txt',
+    'rst',
+    'adoc',
+    'asciidoc',
+    'tex',
+    'latex',
+    // Functional/Other
+    'lua',
+    'pl',
+    'pm',
+    't',
+    'dart',
+    'el',
+    'lisp',
+    'lsp',
+    'scm',
+    'ss',
+    'erl',
+    'hrl',
+    'ex',
+    'exs',
+    'hs',
+    'lhs',
+    'ml',
+    'mli',
+    'v',
+    'vh',
+    'sv',
+    'svh',
+    'coffee',
+    'litcoffee',
+    // API/Structs
+    'proto',
+    'graphql',
+    'gql',
+    'sol',
+    'vy',
+    'tf',
+    'tfvars',
+    'hcl',
+    'nix',
+  ],
+  fileNames: [
+    'Dockerfile',
+    'Containerfile',
+    'Makefile',
+    'Jenkinsfile',
+    'Vagrantfile',
+    'CMakeLists.txt',
+    '.gitignore',
+    '.env',
+    'docker-compose.yml',
+    'docker-compose.yaml',
   ],
   excludePatterns: [
-    "**/node_modules/**",
-    "**/dist/**",
-    "**/build/**",
-    "**/.git/**",
-    "**/coverage/**",
-    "**/.next/**",
-    "**/target/**",
-    "**/vendor/**",
-    "**/.smart-coding-cache/**"
+    '**/node_modules/**',
+    '**/dist/**',
+    '**/build/**',
+    '**/.git/**',
+    '**/coverage/**',
+    '**/.next/**',
+    '**/target/**',
+    '**/vendor/**',
+    '**/.smart-coding-cache/**',
   ],
-  chunkSize: 25, // Lines per chunk (larger = fewer embeddings = faster indexing)
-  chunkOverlap: 5, // Overlap between chunks for context continuity
-  batchSize: 100,
+  chunkSize: 16, // Lines per chunk (tuned for speed/memory balance)
+  chunkOverlap: 4, // Overlap between chunks for context continuity
+  batchSize: 50, // Number of files to process in a single indexing batch
   maxFileSize: 1048576, // 1MB - skip files larger than this
-  maxResults: 5,
-  enableCache: true,
+  prefilterContentMaxBytes: 512 * 1024, // 512KB - cache content during prefilter to avoid double reads
+  maxResults: 5, // Maximum number of semantic search results to return
+  enableCache: true, // Whether to persist and reload embeddings between sessions
+  autoCleanStaleCaches: true, // Automatically remove project caches not accessed for a long time
   cacheDirectory: null, // Will be set dynamically by loadConfig()
-  watchFiles: true,
-  verbose: false,
-  workerThreads: "auto", // "auto" = CPU cores - 1, or set a number
-  embeddingModel: "Xenova/all-MiniLM-L6-v2",
-  semanticWeight: 0.7,
-  exactMatchBoost: 1.5,
+  watchFiles: true, // Enable file system watcher to re-index changed files in real-time
+  verbose: false, // Enable detailed logging for debugging and progress tracking
+  workerThreads: 0, // 0 = run in main thread (no workers), "auto" = CPU cores - 1, or set a number
+  workerBatchTimeoutMs: 120000, // Timeout per worker batch before fallback (ms)
+  workerFailureThreshold: 1, // Open circuit after N worker failures
+  workerFailureCooldownMs: 10 * 60 * 1000, // Cooldown before retrying workers
+  workerMaxChunksPerBatch: 100, // Cap chunks per worker batch to reduce hang risk
+  allowSingleThreadFallback: false, // Allow fallback to main-thread embeddings if workers fail
+  embeddingProcessPerBatch: false, // Use child process per batch for memory isolation
+  embeddingModel: 'jinaai/jina-embeddings-v2-base-code', // AI model ID used for semantic search - can be changed with a lighter model for speed
+  preloadEmbeddingModel: true, // Preload the embedding model at startup (server mode)
+  vectorStoreFormat: 'binary', // json | binary (binary uses mmap-friendly on-disk store)
+  vectorStoreContentMode: 'external', // external = content loaded on-demand for binary store
+  contentCacheEntries: 256, // In-memory content cache entries for binary store
+  vectorStoreLoadMode: 'memory', // memory | disk (disk streams vectors from disk / memory is faster but requires more RAM)
+  vectorCacheEntries: 0, // In-memory vector cache entries for disk-backed loads
+  clearCacheAfterIndex: false, // Drop in-memory vectors after indexing completes
+  semanticWeight: 0.7, // Balance between semantic and keyword scores (0.0 to 1.0)
+  exactMatchBoost: 1.5, // Multiplier applied when an exact string match is found
   recencyBoost: 0.1, // Boost for recently modified files (max 0.1 added to score)
   recencyDecayDays: 30, // After this many days, recency boost is 0
-  smartIndexing: true,
+  smartIndexing: true, // Enable automatic project type detection and smart ignore patterns
   callGraphEnabled: true, // Enable call graph extraction for proximity boosting
-  callGraphBoost: 0.15,   // Boost for files related via call graph (0-1)
-  callGraphMaxHops: 1,    // How many levels of calls to follow (1 = direct only)
-  annEnabled: true,
-  annMinChunks: 5000,
-  annMinCandidates: 50,
-  annMaxCandidates: 200,
-  annCandidateMultiplier: 20,
-  annEfConstruction: 200,
-  annEfSearch: 64,
-  annM: 16,
-  annIndexCache: true,
-  annMetric: "cosine"
+  callGraphBoost: 0.15, // Boost for files related via call graph (0-1)
+  callGraphMaxHops: 1, // How many levels of calls to follow (1 = direct only)
+  annEnabled: true, // Enable Approximate Nearest Neighbor (ANN) index for large codebases
+  annMinChunks: 5000, // Minimum number of chunks required to trigger ANN indexing
+  annMinCandidates: 50, // Minimum initial candidates to pull from ANN before refinement
+  annMaxCandidates: 200, // Hard limit on the number of ANN candidates to process
+  annCandidateMultiplier: 20, // Scale initial search depth based on requested maxResults
+  annEfConstruction: 200, // HNSW index construction quality (higher = better index, slower build)
+  annEfSearch: 64, // HNSW search parameter (higher = more accurate, slower search)
+  annM: 16, // Number of connections per element in HNSW index
+  annIndexCache: true, // Whether to cache the built HNSW index on disk
+  annMetric: 'cosine', // Distance metric for similarity (currently locked to cosine)
 };
 
 let config = { ...DEFAULT_CONFIG };
 
+const WORKSPACE_ENV_VARS = [
+  'HEURISTIC_MCP_WORKSPACE',
+  'MCP_WORKSPACE',
+  'WORKSPACE_FOLDER',
+  'WORKSPACE_ROOT',
+  'CURSOR_WORKSPACE',
+  'CLAUDE_WORKSPACE',
+  'ANTIGRAVITY_WORKSPACE',
+  'INIT_CWD',
+];
+
+const WORKSPACE_MARKERS = [
+  '.git',
+  'package.json',
+  'pyproject.toml',
+  'go.mod',
+  'Cargo.toml',
+  'pom.xml',
+  'build.gradle',
+  'build.gradle.kts',
+  'requirements.txt',
+  'Gemfile',
+  'Makefile',
+  'CMakeLists.txt',
+];
+
+async function pathExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function findWorkspaceRoot(startDir) {
+  let current = path.resolve(startDir);
+  while (true) {
+    for (const marker of WORKSPACE_MARKERS) {
+      if (await pathExists(path.join(current, marker))) {
+        return current;
+      }
+    }
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return path.resolve(startDir);
+}
+
+async function resolveWorkspaceDir(workspaceDir) {
+  if (workspaceDir) return path.resolve(workspaceDir);
+  if (process.env.VITEST === 'true' || process.env.NODE_ENV === 'test') {
+    return path.resolve(process.cwd());
+  }
+
+  for (const key of WORKSPACE_ENV_VARS) {
+    const value = process.env[key];
+    if (!value || value.includes('${')) continue;
+    const candidate = path.resolve(value);
+    if (await pathExists(candidate)) return candidate;
+  }
+
+  return await findWorkspaceRoot(process.cwd());
+}
+
 export async function loadConfig(workspaceDir = null) {
   try {
     // Determine the base directory for configuration
@@ -96,27 +331,27 @@ export async function loadConfig(workspaceDir = null) {
     if (workspaceDir) {
       // Workspace mode: load config from workspace root
       baseDir = path.resolve(workspaceDir);
-      configPath = path.join(baseDir, "config.json");
-      console.error(`[Config] Workspace mode: ${baseDir}`);
+      configPath = path.join(baseDir, 'config.json');
+      console.info(`[Config] Workspace mode: ${baseDir}`);
     } else {
       // Server mode: load config from server directory for global settings,
       // but use process.cwd() as base for searching if not specified otherwise
       const scriptDir = path.dirname(fileURLToPath(import.meta.url));
       const serverDir = path.resolve(scriptDir, '..');
-      configPath = path.join(serverDir, "config.json");
-      baseDir = process.cwd();
+      configPath = path.join(serverDir, 'config.json');
+      baseDir = await resolveWorkspaceDir(null);
     }
 
     let userConfig = {};
     try {
-      const configData = await fs.readFile(configPath, "utf-8");
+      const configData = await fs.readFile(configPath, 'utf-8');
       userConfig = JSON.parse(configData);
-    } catch (configError) {
+    } catch (_configError) {
       // If config not found in server dir, try CWD
       if (!workspaceDir) {
         try {
-          const localConfigPath = path.join(baseDir, "config.json");
-          const configData = await fs.readFile(localConfigPath, "utf-8");
+          const localConfigPath = path.join(baseDir, 'config.json');
+          const configData = await fs.readFile(localConfigPath, 'utf-8');
           userConfig = JSON.parse(configData);
           configPath = localConfigPath;
         } catch {
@@ -127,8 +362,14 @@ export async function loadConfig(workspaceDir = null) {
 
     config = { ...DEFAULT_CONFIG, ...userConfig };
 
-    // Set search and cache directories
-    config.searchDirectory = baseDir;
+    // Set search directory (respect user override when provided)
+    if (userConfig.searchDirectory) {
+      config.searchDirectory = path.isAbsolute(userConfig.searchDirectory)
+        ? userConfig.searchDirectory
+        : path.join(baseDir, userConfig.searchDirectory);
+    } else {
+      config.searchDirectory = baseDir;
+    }
 
     // Determine cache directory
     if (userConfig.cacheDirectory) {
@@ -139,12 +380,16 @@ export async function loadConfig(workspaceDir = null) {
     } else {
       // Use global cache directory to prevent cluttering project root
       // Hash the absolute path to ensure uniqueness per project
-      const projectHash = crypto.createHash('md5').update(baseDir).digest('hex').slice(0, 12);
+      const projectHash = crypto
+        .createHash('md5')
+        .update(config.searchDirectory)
+        .digest('hex')
+        .slice(0, 12);
       const globalCacheRoot = getGlobalCacheDir();
-      config.cacheDirectory = path.join(globalCacheRoot, "heuristic-mcp", projectHash);
+      config.cacheDirectory = path.join(globalCacheRoot, 'heuristic-mcp', projectHash);
 
       // Support legacy .smart-coding-cache if it already exists in the project root
-      const legacyPath = path.join(baseDir, ".smart-coding-cache");
+      const legacyPath = path.join(baseDir, '.smart-coding-cache');
       try {
         const stats = await fs.stat(legacyPath);
         if (stats.isDirectory()) {
@@ -168,22 +413,19 @@ export async function loadConfig(workspaceDir = null) {
 
         // Merge smart patterns with user patterns (user patterns take precedence)
         const userPatterns = userConfig.excludePatterns || [];
-        config.excludePatterns = [
-          ...smartPatterns,
-          ...userPatterns
-        ];
+        config.excludePatterns = [...smartPatterns, ...userPatterns];
 
-        console.error(`[Config] Smart indexing: ${detectedTypes.join(', ')}`);
-        console.error(`[Config] Applied ${smartPatterns.length} smart ignore patterns`);
+        console.info(`[Config] Smart indexing: ${detectedTypes.join(', ')}`);
+        console.info(`[Config] Applied ${smartPatterns.length} smart ignore patterns`);
       } else {
-        console.error("[Config] No project markers detected, using default patterns");
+        console.info('[Config] No project markers detected, using default patterns');
       }
     }
 
-    console.error("[Config] Loaded configuration from config.json");
+    console.info('[Config] Loaded configuration from config.json');
   } catch (error) {
-    console.error("[Config] Using default configuration (config.json not found or invalid)");
-    console.error(`[Config] Error: ${error.message}`);
+    console.warn('[Config] Using default configuration (config.json not found or invalid)');
+    console.warn(`[Config] Error: ${error.message}`);
   }
 
   // Apply environment variable overrides (prefix: SMART_CODING_) with validation
@@ -199,7 +441,9 @@ export async function loadConfig(workspaceDir = null) {
     if (!isNaN(value) && value > 0 && value <= 1000) {
       config.batchSize = value;
     } else {
-      console.error(`[Config] Invalid SMART_CODING_BATCH_SIZE: ${process.env.SMART_CODING_BATCH_SIZE}, using default`);
+      console.warn(
+        `[Config] Invalid SMART_CODING_BATCH_SIZE: ${process.env.SMART_CODING_BATCH_SIZE}, using default`
+      );
     }
   }
 
@@ -208,7 +452,9 @@ export async function loadConfig(workspaceDir = null) {
     if (!isNaN(value) && value > 0) {
       config.maxFileSize = value;
     } else {
-      console.error(`[Config] Invalid SMART_CODING_MAX_FILE_SIZE: ${process.env.SMART_CODING_MAX_FILE_SIZE}, using default`);
+      console.warn(
+        `[Config] Invalid SMART_CODING_MAX_FILE_SIZE: ${process.env.SMART_CODING_MAX_FILE_SIZE}, using default`
+      );
     }
   }
 
@@ -217,7 +463,9 @@ export async function loadConfig(workspaceDir = null) {
     if (!isNaN(value) && value > 0 && value <= 100) {
       config.chunkSize = value;
     } else {
-      console.error(`[Config] Invalid SMART_CODING_CHUNK_SIZE: ${process.env.SMART_CODING_CHUNK_SIZE}, using default`);
+      console.warn(
+        `[Config] Invalid SMART_CODING_CHUNK_SIZE: ${process.env.SMART_CODING_CHUNK_SIZE}, using default`
+      );
     }
   }
 
@@ -226,7 +474,9 @@ export async function loadConfig(workspaceDir = null) {
     if (!isNaN(value) && value > 0 && value <= 100) {
       config.maxResults = value;
     } else {
-      console.error(`[Config] Invalid SMART_CODING_MAX_RESULTS: ${process.env.SMART_CODING_MAX_RESULTS}, using default`);
+      console.warn(
+        `[Config] Invalid SMART_CODING_MAX_RESULTS: ${process.env.SMART_CODING_MAX_RESULTS}, using default`
+      );
     }
   }
 
@@ -242,7 +492,9 @@ export async function loadConfig(workspaceDir = null) {
     if (!isNaN(value) && value >= 0 && value <= 1) {
       config.recencyBoost = value;
     } else {
-      console.error(`[Config] Invalid SMART_CODING_RECENCY_BOOST: ${process.env.SMART_CODING_RECENCY_BOOST}, using default`);
+      console.warn(
+        `[Config] Invalid SMART_CODING_RECENCY_BOOST: ${process.env.SMART_CODING_RECENCY_BOOST}, using default`
+      );
     }
   }
 
@@ -251,7 +503,9 @@ export async function loadConfig(workspaceDir = null) {
     if (!isNaN(value) && value > 0 && value <= 365) {
       config.recencyDecayDays = value;
     } else {
-      console.error(`[Config] Invalid SMART_CODING_RECENCY_DECAY_DAYS: ${process.env.SMART_CODING_RECENCY_DECAY_DAYS}, using default`);
+      console.warn(
+        `[Config] Invalid SMART_CODING_RECENCY_DECAY_DAYS: ${process.env.SMART_CODING_RECENCY_DECAY_DAYS}, using default`
+      );
     }
   }
 
@@ -267,7 +521,9 @@ export async function loadConfig(workspaceDir = null) {
     if (!isNaN(value) && value >= 0 && value <= 1) {
       config.semanticWeight = value;
     } else {
-      console.error(`[Config] Invalid SMART_CODING_SEMANTIC_WEIGHT: ${process.env.SMART_CODING_SEMANTIC_WEIGHT}, using default (must be 0-1)`);
+      console.warn(
+        `[Config] Invalid SMART_CODING_SEMANTIC_WEIGHT: ${process.env.SMART_CODING_SEMANTIC_WEIGHT}, using default (must be 0-1)`
+      );
     }
   }
 
@@ -276,7 +532,9 @@ export async function loadConfig(workspaceDir = null) {
     if (!isNaN(value) && value >= 0) {
       config.exactMatchBoost = value;
     } else {
-      console.error(`[Config] Invalid SMART_CODING_EXACT_MATCH_BOOST: ${process.env.SMART_CODING_EXACT_MATCH_BOOST}, using default`);
+      console.warn(
+        `[Config] Invalid SMART_CODING_EXACT_MATCH_BOOST: ${process.env.SMART_CODING_EXACT_MATCH_BOOST}, using default`
+      );
     }
   }
 
@@ -284,7 +542,80 @@ export async function loadConfig(workspaceDir = null) {
     const value = process.env.SMART_CODING_EMBEDDING_MODEL.trim();
     if (value.length > 0) {
       config.embeddingModel = value;
-      console.error(`[Config] Using custom embedding model: ${value}`);
+      console.info(`[Config] Using custom embedding model: ${value}`);
+    }
+  }
+
+  if (process.env.SMART_CODING_PRELOAD_EMBEDDING_MODEL !== undefined) {
+    const value = process.env.SMART_CODING_PRELOAD_EMBEDDING_MODEL;
+    if (value === 'true' || value === 'false') {
+      config.preloadEmbeddingModel = value === 'true';
+    } else {
+      console.warn(
+        `[Config] Invalid SMART_CODING_PRELOAD_EMBEDDING_MODEL: ${value}, using default`
+      );
+    }
+  }
+
+  if (process.env.SMART_CODING_VECTOR_STORE_FORMAT !== undefined) {
+    const value = process.env.SMART_CODING_VECTOR_STORE_FORMAT.trim().toLowerCase();
+    if (value === 'json' || value === 'binary') {
+      config.vectorStoreFormat = value;
+    } else {
+      console.warn(
+        `[Config] Invalid SMART_CODING_VECTOR_STORE_FORMAT: ${value}, using default`
+      );
+    }
+  }
+
+  if (process.env.SMART_CODING_VECTOR_STORE_CONTENT_MODE !== undefined) {
+    const value = process.env.SMART_CODING_VECTOR_STORE_CONTENT_MODE.trim().toLowerCase();
+    if (value === 'external' || value === 'inline') {
+      config.vectorStoreContentMode = value;
+    } else {
+      console.warn(
+        `[Config] Invalid SMART_CODING_VECTOR_STORE_CONTENT_MODE: ${value}, using default`
+      );
+    }
+  }
+
+  if (process.env.SMART_CODING_VECTOR_STORE_LOAD_MODE !== undefined) {
+    const value = process.env.SMART_CODING_VECTOR_STORE_LOAD_MODE.trim().toLowerCase();
+    if (value === 'memory' || value === 'disk') {
+      config.vectorStoreLoadMode = value;
+    } else {
+      console.warn(
+        `[Config] Invalid SMART_CODING_VECTOR_STORE_LOAD_MODE: ${value}, using default`
+      );
+    }
+  }
+
+  if (process.env.SMART_CODING_CLEAR_CACHE_AFTER_INDEX !== undefined) {
+    const value = process.env.SMART_CODING_CLEAR_CACHE_AFTER_INDEX;
+    if (value === 'true' || value === 'false') {
+      config.clearCacheAfterIndex = value === 'true';
+    }
+  }
+
+  if (process.env.SMART_CODING_CONTENT_CACHE_ENTRIES !== undefined) {
+    const value = parseInt(process.env.SMART_CODING_CONTENT_CACHE_ENTRIES, 10);
+    if (!isNaN(value) && value >= 0 && value <= 10000) {
+      config.contentCacheEntries = value;
+    } else {
+      console.warn(
+        `[Config] Invalid SMART_CODING_CONTENT_CACHE_ENTRIES: ${process.env.SMART_CODING_CONTENT_CACHE_ENTRIES}, using default`
+      );
+    }
+  }
+
+  if (process.env.SMART_CODING_VECTOR_CACHE_ENTRIES !== undefined) {
+    const value = parseInt(process.env.SMART_CODING_VECTOR_CACHE_ENTRIES, 10);
+    if (!isNaN(value) && value >= 0 && value <= 100000) {
+      config.vectorCacheEntries = value;
+    } else {
+      console.warn(
+        `[Config] Invalid SMART_CODING_VECTOR_CACHE_ENTRIES: ${process.env.SMART_CODING_VECTOR_CACHE_ENTRIES}, using default`
+      );
     }
   }
 
@@ -294,10 +625,12 @@ export async function loadConfig(workspaceDir = null) {
       config.workerThreads = 'auto';
     } else {
       const numValue = parseInt(value, 10);
-      if (!isNaN(numValue) && numValue >= 1 && numValue <= 32) {
+      if (!isNaN(numValue) && numValue >= 0 && numValue <= 32) {
         config.workerThreads = numValue;
       } else {
-        console.error(`[Config] Invalid SMART_CODING_WORKER_THREADS: ${value}, using default (must be 'auto' or 1-32)`);
+        console.warn(
+          `[Config] Invalid SMART_CODING_WORKER_THREADS: ${value}, using default (must be 'auto' or 0-32)`
+        );
       }
     }
   }
@@ -314,7 +647,9 @@ export async function loadConfig(workspaceDir = null) {
     if (!isNaN(value) && value >= 0) {
       config.annMinChunks = value;
     } else {
-      console.error(`[Config] Invalid SMART_CODING_ANN_MIN_CHUNKS: ${process.env.SMART_CODING_ANN_MIN_CHUNKS}, using default`);
+      console.warn(
+        `[Config] Invalid SMART_CODING_ANN_MIN_CHUNKS: ${process.env.SMART_CODING_ANN_MIN_CHUNKS}, using default`
+      );
     }
   }
 
@@ -323,7 +658,9 @@ export async function loadConfig(workspaceDir = null) {
     if (!isNaN(value) && value >= 0) {
       config.annMinCandidates = value;
     } else {
-      console.error(`[Config] Invalid SMART_CODING_ANN_MIN_CANDIDATES: ${process.env.SMART_CODING_ANN_MIN_CANDIDATES}, using default`);
+      console.warn(
+        `[Config] Invalid SMART_CODING_ANN_MIN_CANDIDATES: ${process.env.SMART_CODING_ANN_MIN_CANDIDATES}, using default`
+      );
     }
   }
 
@@ -332,7 +669,9 @@ export async function loadConfig(workspaceDir = null) {
     if (!isNaN(value) && value > 0) {
       config.annMaxCandidates = value;
     } else {
-      console.error(`[Config] Invalid SMART_CODING_ANN_MAX_CANDIDATES: ${process.env.SMART_CODING_ANN_MAX_CANDIDATES}, using default`);
+      console.warn(
+        `[Config] Invalid SMART_CODING_ANN_MAX_CANDIDATES: ${process.env.SMART_CODING_ANN_MAX_CANDIDATES}, using default`
+      );
     }
   }
 
@@ -341,7 +680,9 @@ export async function loadConfig(workspaceDir = null) {
     if (!isNaN(value) && value > 0) {
       config.annCandidateMultiplier = value;
     } else {
-      console.error(`[Config] Invalid SMART_CODING_ANN_CANDIDATE_MULTIPLIER: ${process.env.SMART_CODING_ANN_CANDIDATE_MULTIPLIER}, using default`);
+      console.warn(
+        `[Config] Invalid SMART_CODING_ANN_CANDIDATE_MULTIPLIER: ${process.env.SMART_CODING_ANN_CANDIDATE_MULTIPLIER}, using default`
+      );
     }
   }
 
@@ -350,7 +691,9 @@ export async function loadConfig(workspaceDir = null) {
     if (!isNaN(value) && value > 0) {
       config.annEfConstruction = value;
     } else {
-      console.error(`[Config] Invalid SMART_CODING_ANN_EF_CONSTRUCTION: ${process.env.SMART_CODING_ANN_EF_CONSTRUCTION}, using default`);
+      console.warn(
+        `[Config] Invalid SMART_CODING_ANN_EF_CONSTRUCTION: ${process.env.SMART_CODING_ANN_EF_CONSTRUCTION}, using default`
+      );
     }
   }
 
@@ -359,7 +702,9 @@ export async function loadConfig(workspaceDir = null) {
     if (!isNaN(value) && value > 0) {
       config.annEfSearch = value;
     } else {
-      console.error(`[Config] Invalid SMART_CODING_ANN_EF_SEARCH: ${process.env.SMART_CODING_ANN_EF_SEARCH}, using default`);
+      console.warn(
+        `[Config] Invalid SMART_CODING_ANN_EF_SEARCH: ${process.env.SMART_CODING_ANN_EF_SEARCH}, using default`
+      );
     }
   }
 
@@ -368,7 +713,9 @@ export async function loadConfig(workspaceDir = null) {
     if (!isNaN(value) && value > 0 && value <= 64) {
       config.annM = value;
     } else {
-      console.error(`[Config] Invalid SMART_CODING_ANN_M: ${process.env.SMART_CODING_ANN_M}, using default`);
+      console.warn(
+        `[Config] Invalid SMART_CODING_ANN_M: ${process.env.SMART_CODING_ANN_M}, using default`
+      );
     }
   }
 
@@ -381,24 +728,18 @@ export async function loadConfig(workspaceDir = null) {
 
   if (process.env.SMART_CODING_ANN_METRIC !== undefined) {
     const value = process.env.SMART_CODING_ANN_METRIC.trim().toLowerCase();
-    if (value === "cosine" || value === "ip" || value === "l2") {
+    if (value === 'cosine' || value === 'ip' || value === 'l2') {
       config.annMetric = value;
     } else {
-      console.error(`[Config] Invalid SMART_CODING_ANN_METRIC: ${process.env.SMART_CODING_ANN_METRIC}, using default`);
+      console.warn(
+        `[Config] Invalid SMART_CODING_ANN_METRIC: ${process.env.SMART_CODING_ANN_METRIC}, using default`
+      );
     }
   }
 
-  if (config.annMetric !== "cosine") {
-    console.error(`[Config] ANN metric locked to cosine, overriding "${config.annMetric}"`);
-    config.annMetric = "cosine";
-  }
-
-  // Safety cap for auto workers
-  if (config.workerThreads === 'auto') {
-    // Cap at 4 workers max by default to prevent OOM (each model ~150MB)
-    // Users can override this by setting a specific number
-    const cpuCount = process.env.UV_THREADPOOL_SIZE || 4; // Node doesn't expose os.cpus() in some envs
-    // Actual logic happens in index-codebase.js, but we document the intent here
+  if (config.annMetric !== 'cosine') {
+    console.warn(`[Config] ANN metric locked to cosine, overriding "${config.annMetric}"`);
+    config.annMetric = 'cosine';
   }
 
   return config;