@akiojin/unity-mcp-server 2.39.2 → 2.40.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akiojin/unity-mcp-server",
-  "version": "2.39.2",
+  "version": "2.40.1",
   "description": "MCP server and Unity Editor bridge — enables AI assistants to control Unity for AI-assisted workflows",
   "type": "module",
   "main": "src/core/server.js",

package/src/core/config.js

@@ -97,7 +97,7 @@ const baseConfig = {
   // Indexing (code index) settings
   indexing: {
     // Enable periodic incremental index updates (polling watcher)
-    watch: (process.env.INDEX_WATCH || 'false').toLowerCase() === 'true',
+    watch: true,
     // Polling interval (ms)
     intervalMs: Number(process.env.INDEX_WATCH_INTERVAL_MS || 15000),
     // Build options

package/src/core/indexWatcher.js

@@ -34,10 +34,44 @@ export class IndexWatcher {
     if (this.running) return;
     this.running = true;
     try {
+      // Check if code index DB file exists (before opening DB)
+      const { ProjectInfoProvider } = await import('./projectInfo.js');
+      const projectInfo = new ProjectInfoProvider(this.unityConnection);
+      const info = await projectInfo.get();
+      const fs = await import('fs');
+      const path = await import('path');
+      const dbPath = path.default.join(info.codeIndexRoot, 'code-index.db');
+      const dbExists = fs.default.existsSync(dbPath);
+
+      if (!dbExists) {
+        logger.warn('[index] watcher: code index DB file not found, triggering full rebuild');
+        // Force full rebuild when DB file is missing
+        const jobId = `watcher-rebuild-${Date.now()}`;
+        this.currentWatcherJobId = jobId;
+
+        const { CodeIndexBuildToolHandler } = await import(
+          '../handlers/script/CodeIndexBuildToolHandler.js'
+        );
+        const handler = new CodeIndexBuildToolHandler(this.unityConnection);
+
+        this.jobManager.create(jobId, async job => {
+          const params = {
+            concurrency: config.indexing.concurrency || 8,
+            retry: config.indexing.retry || 2,
+            reportPercentage: 10
+          };
+          return await handler._executeBuild(params, job);
+        });
+
+        logger.info(`[index] watcher: started DB rebuild job ${jobId}`);
+        this._monitorJob(jobId);
+        return;
+      }
+
       // Check if manual build is already running (jobs starting with 'build-')
       const allJobs = this.jobManager.getAllJobs();
-      const manualBuildRunning = allJobs.some(job =>
-        job.id.startsWith('build-') && job.status === 'running'
+      const manualBuildRunning = allJobs.some(
+        job => job.id.startsWith('build-') && job.status === 'running'
       );
 
       if (manualBuildRunning) {
@@ -60,15 +94,17 @@ export class IndexWatcher {
       const jobId = `watcher-${Date.now()}`;
       this.currentWatcherJobId = jobId;
 
-      const { CodeIndexBuildToolHandler } = await import('../handlers/script/CodeIndexBuildToolHandler.js');
+      const { CodeIndexBuildToolHandler } = await import(
+        '../handlers/script/CodeIndexBuildToolHandler.js'
+      );
       const handler = new CodeIndexBuildToolHandler(this.unityConnection);
 
       // Create the build job through JobManager
-      this.jobManager.create(jobId, async (job) => {
+      this.jobManager.create(jobId, async job => {
         const params = {
           concurrency: config.indexing.concurrency || 8,
           retry: config.indexing.retry || 2,
-          reportEvery: config.indexing.reportEvery || 500,
+          reportEvery: config.indexing.reportEvery || 500
         };
         return await handler._executeBuild(params, job);
       });
@@ -78,7 +114,6 @@ export class IndexWatcher {
       // Monitor job completion in background
       // (Job result will be logged when it completes/fails)
       this._monitorJob(jobId);
-
     } catch (e) {
       logger.warn(`[index] watcher exception: ${e.message}`);
     } finally {
@@ -101,7 +136,9 @@ export class IndexWatcher {
       }
 
       if (job.status === 'completed') {
-        logger.info(`[index] watcher: auto-build completed - updated=${job.result?.updatedFiles || 0} removed=${job.result?.removedFiles || 0} total=${job.result?.totalIndexedSymbols || 0}`);
+        logger.info(
+          `[index] watcher: auto-build completed - updated=${job.result?.updatedFiles || 0} removed=${job.result?.removedFiles || 0} total=${job.result?.totalIndexedSymbols || 0}`
+        );
         clearInterval(checkInterval);
       } else if (job.status === 'failed') {
         logger.warn(`[index] watcher: auto-build failed - ${job.error}`);

package/src/core/server.js

@@ -232,6 +232,36 @@ export async function startServer() {
     process.on('SIGINT', stopWatch);
     process.on('SIGTERM', stopWatch);
 
+    // Auto-initialize code index if DB doesn't exist
+    (async () => {
+      try {
+        const { CodeIndex } = await import('./codeIndex.js');
+        const index = new CodeIndex(unityConnection);
+        const ready = await index.isReady();
+
+        if (!ready) {
+          logger.info('[startup] Code index DB not ready. Starting auto-build...');
+          const { CodeIndexBuildToolHandler } = await import(
+            '../handlers/script/CodeIndexBuildToolHandler.js'
+          );
+          const builder = new CodeIndexBuildToolHandler(unityConnection);
+          const result = await builder.execute({});
+
+          if (result.success) {
+            logger.info(
+              `[startup] Code index auto-build started: jobId=${result.jobId}. Use code_index_status to check progress.`
+            );
+          } else {
+            logger.warn(`[startup] Code index auto-build failed: ${result.message}`);
+          }
+        } else {
+          logger.info('[startup] Code index DB already exists. Skipping auto-build.');
+        }
+      } catch (e) {
+        logger.warn(`[startup] Code index auto-init failed: ${e.message}`);
+      }
+    })();
+
     // Handle shutdown
     process.on('SIGINT', async () => {
       logger.info('Shutting down...');

package/src/handlers/script/CodeIndexBuildToolHandler.js

@@ -18,12 +18,14 @@ export class CodeIndexBuildToolHandler extends BaseToolHandler {
           throttleMs: {
             type: 'number',
             minimum: 0,
-            description: 'Optional delay in milliseconds after processing each file (testing/debugging).'
+            description:
+              'Optional delay in milliseconds after processing each file (testing/debugging).'
           },
           delayStartMs: {
             type: 'number',
             minimum: 0,
-            description: 'Optional delay before processing begins (useful to keep job in running state briefly).'
+            description:
+              'Optional delay before processing begins (useful to keep job in running state briefly).'
           }
         },
         required: []
@@ -56,7 +58,7 @@ export class CodeIndexBuildToolHandler extends BaseToolHandler {
     this.currentJobId = jobId;
 
     // Create background job
-    this.jobManager.create(jobId, async (job) => {
+    this.jobManager.create(jobId, async job => {
       return await this._executeBuild(params, job);
     });
 
@@ -81,7 +83,7 @@ export class CodeIndexBuildToolHandler extends BaseToolHandler {
       const roots = [
         path.resolve(info.projectRoot, 'Assets'),
         path.resolve(info.projectRoot, 'Packages'),
-        path.resolve(info.projectRoot, 'Library/PackageCache'),
+        path.resolve(info.projectRoot, 'Library/PackageCache')
       ];
       const files = [];
       const seen = new Set();
@@ -94,14 +96,21 @@ export class CodeIndexBuildToolHandler extends BaseToolHandler {
           logger.info(`[index][${job.id}] LSP initialized for project: ${info.projectRoot}`);
         } catch (lspError) {
           logger.error(`[index][${job.id}] LSP initialization failed: ${lspError.message}`);
-          throw new Error(`LSP initialization failed: ${lspError.message}. Ensure C# LSP is properly configured and OmniSharp is available.`);
+          throw new Error(
+            `LSP initialization failed: ${lspError.message}. Ensure C# LSP is properly configured and OmniSharp is available.`
+          );
         }
       }
       const lsp = this.lsp;
 
       // Incremental detection based on size-mtime signature
-      const makeSig = (abs) => {
-        try { const st = fs.statSync(abs); return `${st.size}-${Math.floor(st.mtimeMs)}`; } catch { return '0-0'; }
+      const makeSig = abs => {
+        try {
+          const st = fs.statSync(abs);
+          return `${st.size}-${Math.floor(st.mtimeMs)}`;
+        } catch {
+          return '0-0';
+        }
       };
       const wanted = new Map(files.map(abs => [this.toRel(abs, info.projectRoot), makeSig(abs)]));
       const current = await this.index.getFiles();
@@ -118,7 +127,15 @@ export class CodeIndexBuildToolHandler extends BaseToolHandler {
           const kind = this.kindFromLsp(s.kind);
           const name = s.name || '';
           const start = s.range?.start || s.selectionRange?.start || {};
-          rows.push({ path: rel, name, kind, container: container || null, ns: null, line: (start.line ?? 0) + 1, column: (start.character ?? 0) + 1 });
+          rows.push({
+            path: rel,
+            name,
+            kind,
+            container: container || null,
+            ns: null,
+            line: (start.line ?? 0) + 1,
+            column: (start.character ?? 0) + 1
+          });
           if (Array.isArray(s.children)) for (const c of s.children) visit(c, name || container);
         };
         if (Array.isArray(symbols)) for (const s of symbols) visit(s, null);
@@ -131,19 +148,27 @@ export class CodeIndexBuildToolHandler extends BaseToolHandler {
       // Update changed files
       const absList = changed.map(rel => path.resolve(info.projectRoot, rel));
       const concurrency = Math.max(1, Math.min(64, Number(params?.concurrency ?? 8)));
-      const reportEvery = Math.max(1, Number(params?.reportEvery ?? 100));
+      const reportPercentage = Math.max(1, Math.min(100, Number(params?.reportPercentage ?? 10)));
       const startAt = Date.now();
-      let i = 0; let updated = 0; let processed = 0;
+      let i = 0;
+      let updated = 0;
+      let processed = 0;
+      let lastReportedPercentage = 0;
 
       // Initialize progress
       job.progress.total = absList.length;
       job.progress.processed = 0;
       job.progress.rate = 0;
 
-      logger.info(`[index][${job.id}] Build started: ${absList.length} files to process, ${removed.length} to remove (status: ${job.status})`);
+      logger.info(
+        `[index][${job.id}] Build started: ${absList.length} files to process, ${removed.length} to remove (status: ${job.status})`
+      );
 
       // LSP request with small retry/backoff
-      const requestWithRetry = async (uri, maxRetries = Math.max(0, Math.min(5, Number(params?.retry ?? 2)))) => {
+      const requestWithRetry = async (
+        uri,
+        maxRetries = Math.max(0, Math.min(5, Number(params?.retry ?? 2)))
+      ) => {
         let lastErr = null;
         for (let attempt = 0; attempt <= maxRetries; attempt++) {
           try {
@@ -180,17 +205,26 @@ export class CodeIndexBuildToolHandler extends BaseToolHandler {
               // Log occasionally to avoid spam
               logger.warn(`[index][${job.id}] Skipped file due to error: ${rel} - ${err.message}`);
             }
-          }
-          finally {
+          } finally {
             processed += 1;
 
             // Update job progress
             const elapsed = Math.max(1, Date.now() - startAt);
             job.progress.processed = processed;
-            job.progress.rate = parseFloat((processed * 1000 / elapsed).toFixed(1));
+            job.progress.rate = parseFloat(((processed * 1000) / elapsed).toFixed(1));
 
-            if (processed % reportEvery === 0 || processed === absList.length) {
-              logger.info(`[index][${job.id}] progress ${processed}/${absList.length} (removed:${removed.length}) rate:${job.progress.rate} f/s (status: ${job.status})`);
+            // Calculate current percentage
+            const currentPercentage = Math.floor((processed / absList.length) * 100);
+
+            // Log when percentage increases by reportPercentage (default: 10%)
+            if (
+              currentPercentage >= lastReportedPercentage + reportPercentage ||
+              processed === absList.length
+            ) {
+              logger.info(
+                `[index][${job.id}] progress ${currentPercentage}% (${processed}/${absList.length}) removed:${removed.length} rate:${job.progress.rate} f/s`
+              );
+              lastReportedPercentage = currentPercentage;
             }
 
             if (throttleMs > 0) {
@@ -216,7 +250,9 @@ export class CodeIndexBuildToolHandler extends BaseToolHandler {
         lastIndexedAt: stats.lastIndexedAt
       };
 
-      logger.info(`[index][${job.id}] Build completed successfully: updated=${result.updatedFiles}, removed=${result.removedFiles}, total=${result.totalIndexedSymbols} (status: completed)`);
+      logger.info(
+        `[index][${job.id}] Build completed successfully: updated=${result.updatedFiles}, removed=${result.removedFiles}, total=${result.totalIndexedSymbols} (status: completed)`
+      );
 
       return result;
     } catch (e) {
@@ -242,7 +278,10 @@ export class CodeIndexBuildToolHandler extends BaseToolHandler {
       if (!fs.existsSync(root)) return;
       const st = fs.statSync(root);
       if (st.isFile()) {
-        if (root.endsWith('.cs') && !seen.has(root)) { files.push(root); seen.add(root); }
+        if (root.endsWith('.cs') && !seen.has(root)) {
+          files.push(root);
+          seen.add(root);
+        }
         return;
       }
       const entries = fs.readdirSync(root, { withFileTypes: true });
@@ -261,13 +300,22 @@ export class CodeIndexBuildToolHandler extends BaseToolHandler {
 
   kindFromLsp(k) {
     switch (k) {
-      case 5: return 'class';
-      case 23: return 'struct';
-      case 11: return 'interface';
-      case 10: return 'enum';
-      case 6: return 'method';
-      case 7: return 'property';
-      case 8: return 'field';
-      case 3: return 'namespace';    }
+      case 5:
+        return 'class';
+      case 23:
+        return 'struct';
+      case 11:
+        return 'interface';
+      case 10:
+        return 'enum';
+      case 6:
+        return 'method';
+      case 7:
+        return 'property';
+      case 8:
+        return 'field';
+      case 3:
+        return 'namespace';
+    }
   }
 }