@akiojin/unity-mcp-server 2.45.5 → 3.0.0

package/src/core/codeIndex.js

@@ -1,8 +1,21 @@
 import fs from 'fs';
 import path from 'path';
+import { LRUCache } from 'lru-cache';
 import { ProjectInfoProvider } from './projectInfo.js';
 import { logger } from './config.js';
 
+// Phase 4: Query result cache (80% reduction for repeated queries)
+const queryCache = new LRUCache({
+  max: 500, // Max 500 cached queries
+  ttl: 1000 * 60 * 5 // 5 minute TTL
+});
+
+// Stats cache with shorter TTL
+const statsCache = new LRUCache({
+  max: 1,
+  ttl: 1000 * 60 // 1 minute TTL for stats
+});
+
 // fast-sql helper: execute query and return results
 function querySQL(db, sql) {
   return db.execSql(sql);
@@ -138,7 +151,10 @@ export class CodeIndex {
 
   _initSchema() {
     if (!this.db) return;
-    // fast-sql applies optimal PRAGMAs automatically
+    // Phase 5: Explicit PRAGMA optimization
+    this.db.run('PRAGMA cache_size = 16000'); // 64MB cache (16000 * 4KB pages)
+    this.db.run('PRAGMA temp_store = MEMORY'); // Faster temp operations
+    this.db.run('PRAGMA synchronous = NORMAL'); // Balanced safety/speed
     this.db.run(`
       CREATE TABLE IF NOT EXISTS meta (
         key TEXT PRIMARY KEY,
@@ -166,6 +182,9 @@ export class CodeIndex {
     this.db.run('CREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name)');
     this.db.run('CREATE INDEX IF NOT EXISTS idx_symbols_kind ON symbols(kind)');
     this.db.run('CREATE INDEX IF NOT EXISTS idx_symbols_path ON symbols(path)');
+    // Composite indexes for faster multi-condition queries
+    this.db.run('CREATE INDEX IF NOT EXISTS idx_symbols_name_kind ON symbols(name, kind)');
+    this.db.run('CREATE INDEX IF NOT EXISTS idx_symbols_path_name ON symbols(path, name)');
     this._saveToFile();
   }
 
@@ -181,6 +200,10 @@ export class CodeIndex {
     const db = await this.open();
     if (!db) throw new Error('CodeIndex is unavailable (fast-sql not loaded)');
 
+    // Phase 4: Invalidate caches on write
+    queryCache.clear();
+    statsCache.clear();
+
     db.run('BEGIN TRANSACTION');
     try {
       db.run('DELETE FROM symbols');
@@ -232,6 +255,8 @@ export class CodeIndex {
   async upsertFile(pathStr, sig) {
     const db = await this.open();
     if (!db) return;
+    // Phase 4: Invalidate caches on write
+    statsCache.clear();
     const stmt = db.prepare('REPLACE INTO files(path,sig,updatedAt) VALUES (?,?,?)');
     stmt.run([pathStr, sig || '', new Date().toISOString()]);
     stmt.free();
@@ -241,6 +266,9 @@ export class CodeIndex {
   async removeFile(pathStr) {
     const db = await this.open();
     if (!db) return;
+    // Phase 4: Invalidate caches on write
+    queryCache.clear();
+    statsCache.clear();
     db.run('BEGIN TRANSACTION');
     try {
       const stmt1 = db.prepare('DELETE FROM symbols WHERE path = ?');
@@ -263,6 +291,10 @@ export class CodeIndex {
     const db = await this.open();
     if (!db) return;
 
+    // Phase 4: Invalidate caches on write
+    queryCache.clear();
+    statsCache.clear();
+
     db.run('BEGIN TRANSACTION');
     try {
       const delStmt = db.prepare('DELETE FROM symbols WHERE path = ?');
@@ -298,6 +330,11 @@ export class CodeIndex {
   }
 
   async querySymbols({ name, kind, scope = 'all', exact = false }) {
+    // Phase 4: Check cache first
+    const cacheKey = JSON.stringify({ name, kind, scope, exact });
+    const cached = queryCache.get(cacheKey);
+    if (cached) return cached;
+
     const db = await this.open();
     if (!db) return [];
 
@@ -318,6 +355,16 @@ export class CodeIndex {
       params.push(kind);
     }
 
+    // Apply scope filter directly in SQL for better performance
+    if (scope === 'assets') {
+      sql += " AND path LIKE 'Assets/%'";
+    } else if (scope === 'packages') {
+      sql += " AND (path LIKE 'Packages/%' OR path LIKE '%Library/PackageCache/%')";
+    } else if (scope === 'embedded') {
+      sql += " AND path LIKE 'Packages/%'";
+    }
+    // scope === 'all' requires no additional filter
+
     const stmt = db.prepare(sql);
     if (params.length > 0) {
       stmt.bind(params);
@@ -330,17 +377,7 @@ export class CodeIndex {
     }
     stmt.free();
 
-    // Apply path-based scope filter in JS
-    const filtered = rows.filter(r => {
-      const p = String(r.path || '').replace(/\\/g, '/');
-      if (scope === 'assets') return p.startsWith('Assets/');
-      if (scope === 'packages')
-        return p.startsWith('Packages/') || p.includes('Library/PackageCache/');
-      if (scope === 'embedded') return p.startsWith('Packages/');
-      return true;
-    });
-
-    return filtered.map(r => ({
+    const result = rows.map(r => ({
       path: r.path,
       name: r.name,
       kind: r.kind,
@@ -349,9 +386,17 @@ export class CodeIndex {
       line: r.line,
       column: r.column
     }));
+
+    // Cache the result
+    queryCache.set(cacheKey, result);
+    return result;
   }
 
   async getStats() {
+    // Phase 4: Check stats cache first
+    const cached = statsCache.get('stats');
+    if (cached) return cached;
+
     const db = await this.open();
     if (!db) return { total: 0, lastIndexedAt: null };
 
@@ -363,7 +408,9 @@ export class CodeIndex {
     const last =
       metaResult.length > 0 && metaResult[0].values.length > 0 ? metaResult[0].values[0][0] : null;
 
-    return { total, lastIndexedAt: last };
+    const result = { total, lastIndexedAt: last };
+    statsCache.set('stats', result);
+    return result;
   }
 
   /**
@@ -387,6 +434,9 @@ export function __resetCodeIndexDriverStatusForTest() {
   driverStatus.available = null;
   driverStatus.error = null;
   driverStatus.logged = false;
+  // Phase 4: Clear query caches
+  queryCache.clear();
+  statsCache.clear();
   // Also reset shared connections
   if (sharedConnections.db) {
     try {

package/src/core/config.js

@@ -1,4 +1,5 @@
 import fs from 'fs';
+import os from 'os';
 import path from 'path';
 import * as findUpPkg from 'find-up';
 import { MCPLogger } from './mcpLogger.js';
@@ -67,20 +68,13 @@ function resolvePackageVersion() {
 /**
  * Base configuration for Unity MCP Server Server
  */
-const envUnityHost = process.env.UNITY_BIND_HOST || process.env.UNITY_HOST || null;
-
-const envMcpHost =
-  process.env.UNITY_MCP_HOST || process.env.UNITY_CLIENT_HOST || process.env.UNITY_HOST || null;
-
-const envBindHost = process.env.UNITY_BIND_HOST || null;
-
 const baseConfig = {
   // Unity connection settings
   unity: {
-    unityHost: envUnityHost,
-    mcpHost: envMcpHost,
-    bindHost: envBindHost,
-    port: parseInt(process.env.UNITY_PORT || '', 10) || 6400,
+    unityHost: null,
+    mcpHost: null,
+    bindHost: null,
+    port: 6400,
     reconnectDelay: 1000,
     maxReconnectDelay: 30000,
     reconnectBackoffMultiplier: 2,
@@ -96,24 +90,21 @@ const baseConfig = {
 
   // Logging settings
   logging: {
-    level: process.env.LOG_LEVEL || 'info',
+    level: 'info',
     prefix: '[unity-mcp-server]'
   },
 
   // HTTP transport (off by default)
   http: {
-    enabled: (process.env.UNITY_MCP_HTTP_ENABLED || 'false').toLowerCase() === 'true',
-    host: process.env.UNITY_MCP_HTTP_HOST || '0.0.0.0',
-    port: parseInt(process.env.UNITY_MCP_HTTP_PORT || '', 10) || 6401,
+    enabled: false,
+    host: '0.0.0.0',
+    port: 6401,
     healthPath: '/healthz',
-    allowedHosts: (process.env.UNITY_MCP_HTTP_ALLOWED_HOSTS || 'localhost,127.0.0.1')
-      .split(',')
-      .map(h => h.trim())
-      .filter(h => h.length > 0)
+    allowedHosts: ['localhost', '127.0.0.1']
   },
 
   telemetry: {
-    enabled: (process.env.UNITY_MCP_TELEMETRY || 'off').toLowerCase() === 'on',
+    enabled: false,
     destinations: [],
     fields: []
   },
@@ -123,13 +114,13 @@ const baseConfig = {
   // Search-related defaults and engine selection
   search: {
     // detail alias: 'compact' maps to returnMode 'snippets'
-    defaultDetail: (process.env.SEARCH_DEFAULT_DETAIL || 'compact').toLowerCase(), // compact|metadata|snippets|full
-    engine: (process.env.SEARCH_ENGINE || 'naive').toLowerCase() // naive|treesitter (future)
+    defaultDetail: 'compact', // compact|metadata|snippets|full
+    engine: 'naive' // naive|treesitter (future)
   },
 
   // LSP client defaults
   lsp: {
-    requestTimeoutMs: Number(process.env.LSP_REQUEST_TIMEOUT_MS || 60000)
+    requestTimeoutMs: 60000
   },
 
   // Indexing (code index) settings
@@ -137,95 +128,48 @@ const baseConfig = {
     // Enable periodic incremental index updates (polling watcher)
     watch: true,
     // Polling interval (ms)
-    intervalMs: Number(process.env.INDEX_WATCH_INTERVAL_MS || 15000),
+    intervalMs: 15000,
     // Build options
-    concurrency: Number(process.env.INDEX_CONCURRENCY || 8),
-    retry: Number(process.env.INDEX_RETRY || 2),
-    reportEvery: Number(process.env.INDEX_REPORT_EVERY || 500)
+    concurrency: 8,
+    retry: 2,
+    reportEvery: 500
   }
 };
 
 /**
- * External config resolution (no legacy compatibility):
- * Priority:
- * 1) UNITY_MCP_CONFIG (explicit file path)
- * 2) ./.unity/config.json (project-local)
- * 3) ~/.unity/config.json (user-global)
- * If none found, create ./.unity/config.json with defaults.
+ * External config resolution:
+ * - Uses the nearest `.unity/config.json` found by walking up from the current working directory.
+ * - Intentionally ignores `~/.unity/config.json` (user-global).
  */
-function ensureDefaultProjectConfig(baseDir) {
-  const dir = path.resolve(baseDir, '.unity');
-  const file = path.join(dir, 'config.json');
-
-  try {
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-
-    if (!fs.existsSync(file)) {
-      const inferredRoot = fs.existsSync(path.join(baseDir, 'Assets')) ? baseDir : '';
-      const defaultConfig = {
-        unity: {
-          unityHost: 'localhost',
-          mcpHost: 'localhost',
-          port: 6400
-        },
-        project: {
-          root: inferredRoot ? inferredRoot.replace(/\\/g, '/') : ''
-        }
-      };
-      fs.writeFileSync(file, `${JSON.stringify(defaultConfig, null, 2)}\n`, 'utf8');
-    }
-    return file;
-  } catch (error) {
-    return null;
-  }
-}
-
 function loadExternalConfig() {
   if (typeof findUpSyncCompat !== 'function') {
     return {};
   }
-  const explicitPath = process.env.UNITY_MCP_CONFIG;
+  let userGlobalPath = null;
+  try {
+    const homeDir = os.homedir();
+    userGlobalPath = homeDir ? path.resolve(homeDir, '.unity', 'config.json') : null;
+  } catch {}
 
   const projectPath = findUpSyncCompat(
     directory => {
       const candidate = path.resolve(directory, '.unity', 'config.json');
+      if (userGlobalPath && path.resolve(candidate) === userGlobalPath) return undefined;
       return fs.existsSync(candidate) ? candidate : undefined;
     },
     { cwd: process.cwd() }
   );
-  const homeDir = process.env.HOME || process.env.USERPROFILE || '';
-  const userPath = homeDir ? path.resolve(homeDir, '.unity', 'config.json') : null;
 
-  const candidates = [explicitPath, projectPath, userPath].filter(Boolean);
-  for (const p of candidates) {
-    try {
-      if (p && fs.existsSync(p)) {
-        const raw = fs.readFileSync(p, 'utf8');
-        const json = JSON.parse(raw);
-        const out = json && typeof json === 'object' ? json : {};
-        out.__configPath = p;
-        return out;
-      }
-    } catch (e) {
-      return { __configLoadError: `${p}: ${e.message}` };
-    }
-  }
-  const fallbackPath = ensureDefaultProjectConfig(process.cwd());
-  if (fallbackPath && fs.existsSync(fallbackPath)) {
-    try {
-      const raw = fs.readFileSync(fallbackPath, 'utf8');
-      const json = JSON.parse(raw);
-      const out = json && typeof json === 'object' ? json : {};
-      out.__configPath = fallbackPath;
-      out.__configGenerated = true;
-      return out;
-    } catch (e) {
-      return { __configLoadError: `${fallbackPath}: ${e.message}` };
-    }
+  if (!projectPath) return {};
+  try {
+    const raw = fs.readFileSync(projectPath, 'utf8');
+    const json = JSON.parse(raw);
+    const out = json && typeof json === 'object' ? json : {};
+    out.__configPath = projectPath;
+    return out;
+  } catch (e) {
+    return { __configLoadError: `${projectPath}: ${e.message}` };
   }
-  return {};
 }
 
 const external = loadExternalConfig();
@@ -234,22 +178,22 @@ export const config = merge(baseConfig, external);
 const normalizeUnityConfig = () => {
   const unityConfig = config.unity || (config.unity = {});
 
-  // Legacy aliases coming from config files or env vars
+  // Legacy aliases coming from config files
   const legacyHost = unityConfig.host;
   const legacyClientHost = unityConfig.clientHost;
   const legacyBindHost = unityConfig.bindHost;
 
   if (!unityConfig.unityHost) {
-    unityConfig.unityHost = legacyBindHost || legacyHost || envUnityHost || 'localhost';
+    unityConfig.unityHost = legacyBindHost || legacyHost || 'localhost';
   }
 
   if (!unityConfig.mcpHost) {
-    unityConfig.mcpHost = legacyClientHost || envMcpHost || legacyHost || unityConfig.unityHost;
+    unityConfig.mcpHost = legacyClientHost || legacyHost || unityConfig.unityHost;
   }
 
   // Keep bindHost for backwards compatibility with legacy code paths
   if (!unityConfig.bindHost) {
-    unityConfig.bindHost = legacyBindHost || envBindHost || unityConfig.unityHost;
+    unityConfig.bindHost = legacyBindHost || unityConfig.unityHost;
   }
 
   // Maintain legacy properties so older handlers keep working
@@ -291,7 +235,7 @@ if (config.__configLoadError) {
 // Startup debug log: output config info to stderr for troubleshooting
 // This helps diagnose connection issues (especially in WSL2/Docker environments)
 console.error(`[unity-mcp-server] Startup config:`);
-console.error(`[unity-mcp-server]   Config file: ${config.__configPath || '(defaults)'}`);
+console.error(`[unity-mcp-server]   Config file: ${config.__configPath || '(not found)'}`);
 console.error(
   `[unity-mcp-server]   Unity host: ${config.unity.mcpHost || config.unity.unityHost || 'localhost'}`
 );

package/src/core/projectInfo.js

@@ -1,8 +1,36 @@
+import fs from 'fs';
 import path from 'path';
 import { logger, config, WORKSPACE_ROOT } from './config.js';
 
 const normalize = p => p.replace(/\\/g, '/');
 
+const looksLikeUnityProjectRoot = dir => {
+  try {
+    return (
+      fs.existsSync(path.join(dir, 'Assets')) &&
+      fs.existsSync(path.join(dir, 'Packages')) &&
+      fs.statSync(path.join(dir, 'Assets')).isDirectory() &&
+      fs.statSync(path.join(dir, 'Packages')).isDirectory()
+    );
+  } catch {
+    return false;
+  }
+};
+
+const inferUnityProjectRootFromDir = startDir => {
+  try {
+    let dir = startDir;
+    const { root } = path.parse(dir);
+    while (true) {
+      if (looksLikeUnityProjectRoot(dir)) return dir;
+      if (dir === root) return null;
+      dir = path.dirname(dir);
+    }
+  } catch {
+    return null;
+  }
+};
+
 const resolveDefaultCodeIndexRoot = projectRoot => {
   const base = WORKSPACE_ROOT || projectRoot || process.cwd();
   return normalize(path.join(base, '.unity', 'cache', 'code-index'));
@@ -18,21 +46,6 @@ export class ProjectInfoProvider {
 
   async get() {
     if (this.cached) return this.cached;
-    // Env-driven project root override (primarily for tests)
-    const envRootRaw = process.env.UNITY_PROJECT_ROOT;
-    if (typeof envRootRaw === 'string' && envRootRaw.trim().length > 0) {
-      const envRoot = envRootRaw.trim();
-      const projectRoot = normalize(path.resolve(envRoot));
-      const codeIndexRoot = normalize(resolveDefaultCodeIndexRoot(projectRoot));
-      this.cached = {
-        projectRoot,
-        assetsPath: normalize(path.join(projectRoot, 'Assets')),
-        packagesPath: normalize(path.join(projectRoot, 'Packages')),
-        codeIndexRoot
-      };
-      return this.cached;
-    }
-
     // Config-driven project root (no env fallback)
     const cfgRootRaw = config?.project?.root;
     if (typeof cfgRootRaw === 'string' && cfgRootRaw.trim().length > 0) {
@@ -73,13 +86,28 @@ export class ProjectInfoProvider {
         logger.warning(`get_editor_info failed: ${e.message}`);
       }
     }
+
+    // Best-effort local inference (when Unity isn't connected)
+    const inferredRoot = inferUnityProjectRootFromDir(process.cwd());
+    if (inferredRoot) {
+      const projectRoot = normalize(inferredRoot);
+      const codeIndexRoot = normalize(resolveDefaultCodeIndexRoot(projectRoot));
+      this.cached = {
+        projectRoot,
+        assetsPath: normalize(path.join(projectRoot, 'Assets')),
+        packagesPath: normalize(path.join(projectRoot, 'Packages')),
+        codeIndexRoot
+      };
+      return this.cached;
+    }
+
     if (typeof cfgRootRaw === 'string') {
       throw new Error(
-        'project.root is configured but empty. Set a valid path in .unity/config.json or UNITY_MCP_CONFIG.'
+        'project.root is configured but empty. Set a valid path in .unity/config.json.'
       );
     }
     throw new Error(
-      'Unable to resolve Unity project root. Configure project.root in .unity/config.json or provide UNITY_MCP_CONFIG.'
+      'Unable to resolve Unity project root. Start the server inside a Unity project (directory containing Assets/ and Packages/) or configure project.root in .unity/config.json.'
     );
   }