@openez-graph/cli 0.2.1 → 0.3.1

package/dist/cli.cjs

@@ -2912,7 +2912,7 @@ var require_command = __commonJS({
     var EventEmitter2 = require("events").EventEmitter;
     var childProcess = require("child_process");
     var path19 = require("path");
-    var fs16 = require("fs");
+    var fs17 = require("fs");
     var process3 = require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -3906,7 +3906,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} subcommandName
        */
       _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
-        if (fs16.existsSync(executableFile)) return;
+        if (fs17.existsSync(executableFile)) return;
         const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
         const executableMissing = `'${executableFile}' does not exist
  - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
@@ -3925,10 +3925,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
           const localBin = path19.resolve(baseDir, baseName);
-          if (fs16.existsSync(localBin)) return localBin;
+          if (fs17.existsSync(localBin)) return localBin;
           if (sourceExt.includes(path19.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs16.existsSync(`${localBin}${ext}`)
+            (ext) => fs17.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -3940,7 +3940,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs16.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs17.realpathSync(this._scriptPath);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
@@ -12514,7 +12514,7 @@ var require_package = __commonJS({
 var require_main = __commonJS({
   "../../node_modules/.pnpm/dotenv@16.6.1/node_modules/dotenv/lib/main.js"(exports2, module3) {
     "use strict";
-    var fs16 = require("fs");
+    var fs17 = require("fs");
     var path19 = require("path");
     var os6 = require("os");
     var crypto4 = require("crypto");
@@ -12623,7 +12623,7 @@ var require_main = __commonJS({
       if (options && options.path && options.path.length > 0) {
         if (Array.isArray(options.path)) {
           for (const filepath of options.path) {
-            if (fs16.existsSync(filepath)) {
+            if (fs17.existsSync(filepath)) {
               possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
             }
           }
@@ -12633,7 +12633,7 @@ var require_main = __commonJS({
       } else {
         possibleVaultPath = path19.resolve(process.cwd(), ".env.vault");
       }
-      if (fs16.existsSync(possibleVaultPath)) {
+      if (fs17.existsSync(possibleVaultPath)) {
         return possibleVaultPath;
       }
       return null;
@@ -12682,7 +12682,7 @@ var require_main = __commonJS({
       const parsedAll = {};
       for (const path20 of optionPaths) {
         try {
-          const parsed = DotenvModule.parse(fs16.readFileSync(path20, { encoding }));
+          const parsed = DotenvModule.parse(fs17.readFileSync(path20, { encoding }));
           DotenvModule.populate(parsedAll, parsed, options);
         } catch (e) {
           if (debug) {
@@ -29609,11 +29609,11 @@ var require_source_map_support = __commonJS({
     "use strict";
     var SourceMapConsumer = require_source_map().SourceMapConsumer;
     var path19 = require("path");
-    var fs16;
+    var fs17;
     try {
-      fs16 = require("fs");
-      if (!fs16.existsSync || !fs16.readFileSync) {
-        fs16 = null;
+      fs17 = require("fs");
+      if (!fs17.existsSync || !fs17.readFileSync) {
+        fs17 = null;
       }
     } catch (err) {
     }
@@ -29684,7 +29684,7 @@ var require_source_map_support = __commonJS({
       }
       var contents = "";
       try {
-        if (!fs16) {
+        if (!fs17) {
           var xhr = new XMLHttpRequest();
           xhr.open(
             "GET",
@@ -29696,8 +29696,8 @@ var require_source_map_support = __commonJS({
           if (xhr.readyState === 4 && xhr.status === 200) {
             contents = xhr.responseText;
           }
-        } else if (fs16.existsSync(path20)) {
-          contents = fs16.readFileSync(path20, "utf8");
+        } else if (fs17.existsSync(path20)) {
+          contents = fs17.readFileSync(path20, "utf8");
         }
       } catch (er) {
       }
@@ -29961,9 +29961,9 @@ var require_source_map_support = __commonJS({
         var line = +match[2];
         var column = +match[3];
         var contents = fileContentsCache[source];
-        if (!contents && fs16 && fs16.existsSync(source)) {
+        if (!contents && fs17 && fs17.existsSync(source)) {
           try {
-            contents = fs16.readFileSync(source, "utf8");
+            contents = fs17.readFileSync(source, "utf8");
           } catch (er) {
             contents = "";
           }
@@ -33724,10 +33724,10 @@ var require_typescript = __commonJS({
       function and2(f, g2) {
         return (arg) => f(arg) && g2(arg);
       }
-      function or2(...fs16) {
+      function or2(...fs17) {
         return (...args) => {
           let lastResult;
-          for (const f of fs16) {
+          for (const f of fs17) {
             lastResult = f(...args);
             if (lastResult) {
               return lastResult;
@@ -35302,7 +35302,7 @@ ${lanes.join("\n")}
       var tracing;
       var tracingEnabled;
       ((tracingEnabled2) => {
-        let fs16;
+        let fs17;
         let traceCount = 0;
         let traceFd = 0;
         let mode;
@@ -35311,9 +35311,9 @@ ${lanes.join("\n")}
         const legend = [];
         function startTracing2(tracingMode, traceDir, configFilePath) {
           Debug.assert(!tracing, "Tracing already started");
-          if (fs16 === void 0) {
+          if (fs17 === void 0) {
             try {
-              fs16 = require("fs");
+              fs17 = require("fs");
             } catch (e) {
               throw new Error(`tracing requires having fs
 (original error: ${e.message || e})`);
@@ -35324,8 +35324,8 @@ ${lanes.join("\n")}
           if (legendPath === void 0) {
             legendPath = combinePaths(traceDir, "legend.json");
           }
-          if (!fs16.existsSync(traceDir)) {
-            fs16.mkdirSync(traceDir, { recursive: true });
+          if (!fs17.existsSync(traceDir)) {
+            fs17.mkdirSync(traceDir, { recursive: true });
           }
           const countPart = mode === "build" ? `.${process.pid}-${++traceCount}` : mode === "server" ? `.${process.pid}` : ``;
           const tracePath = combinePaths(traceDir, `trace${countPart}.json`);
@@ -35335,10 +35335,10 @@ ${lanes.join("\n")}
             tracePath,
             typesPath
           });
-          traceFd = fs16.openSync(tracePath, "w");
+          traceFd = fs17.openSync(tracePath, "w");
           tracing = tracingEnabled2;
           const meta = { cat: "__metadata", ph: "M", ts: 1e3 * timestamp(), pid: 1, tid: 1 };
-          fs16.writeSync(
+          fs17.writeSync(
             traceFd,
             "[\n" + [{ name: "process_name", args: { name: "tsc" }, ...meta }, { name: "thread_name", args: { name: "Main" }, ...meta }, { name: "TracingStartedInBrowser", ...meta, cat: "disabled-by-default-devtools.timeline" }].map((v) => JSON.stringify(v)).join(",\n")
           );
@@ -35347,10 +35347,10 @@ ${lanes.join("\n")}
         function stopTracing() {
           Debug.assert(tracing, "Tracing is not in progress");
           Debug.assert(!!typeCatalog.length === (mode !== "server"));
-          fs16.writeSync(traceFd, `
+          fs17.writeSync(traceFd, `
 ]
 `);
-          fs16.closeSync(traceFd);
+          fs17.closeSync(traceFd);
           tracing = void 0;
           if (typeCatalog.length) {
             dumpTypes(typeCatalog);
@@ -35422,11 +35422,11 @@ ${lanes.join("\n")}
         function writeEvent(eventType, phase, name, args, extras, time3 = 1e3 * timestamp()) {
           if (mode === "server" && phase === "checkTypes") return;
           mark("beginTracing");
-          fs16.writeSync(traceFd, `,
+          fs17.writeSync(traceFd, `,
 {"pid":1,"tid":1,"ph":"${eventType}","cat":"${phase}","ts":${time3},"name":"${name}"`);
-          if (extras) fs16.writeSync(traceFd, `,${extras}`);
-          if (args) fs16.writeSync(traceFd, `,"args":${JSON.stringify(args)}`);
-          fs16.writeSync(traceFd, `}`);
+          if (extras) fs17.writeSync(traceFd, `,${extras}`);
+          if (args) fs17.writeSync(traceFd, `,"args":${JSON.stringify(args)}`);
+          fs17.writeSync(traceFd, `}`);
           mark("endTracing");
           measure("Tracing", "beginTracing", "endTracing");
         }
@@ -35448,9 +35448,9 @@ ${lanes.join("\n")}
           var _a3, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s;
           mark("beginDumpTypes");
           const typesPath = legend[legend.length - 1].typesPath;
-          const typesFd = fs16.openSync(typesPath, "w");
+          const typesFd = fs17.openSync(typesPath, "w");
           const recursionIdentityMap = /* @__PURE__ */ new Map();
-          fs16.writeSync(typesFd, "[");
+          fs17.writeSync(typesFd, "[");
           const numTypes = types.length;
           for (let i = 0; i < numTypes; i++) {
             const type = types[i];
@@ -35546,13 +35546,13 @@ ${lanes.join("\n")}
               flags: Debug.formatTypeFlags(type.flags).split("|"),
               display
             };
-            fs16.writeSync(typesFd, JSON.stringify(descriptor));
+            fs17.writeSync(typesFd, JSON.stringify(descriptor));
             if (i < numTypes - 1) {
-              fs16.writeSync(typesFd, ",\n");
+              fs17.writeSync(typesFd, ",\n");
             }
           }
-          fs16.writeSync(typesFd, "]\n");
-          fs16.closeSync(typesFd);
+          fs17.writeSync(typesFd, "]\n");
+          fs17.closeSync(typesFd);
           mark("endDumpTypes");
           measure("Dump types", "beginDumpTypes", "endDumpTypes");
         }
@@ -35560,7 +35560,7 @@ ${lanes.join("\n")}
           if (!legendPath) {
             return;
           }
-          fs16.writeFileSync(legendPath, JSON.stringify(legend));
+          fs17.writeFileSync(legendPath, JSON.stringify(legend));
         }
         tracingEnabled2.dumpLegend = dumpLegend;
       })(tracingEnabled || (tracingEnabled = {}));
@@ -244613,8 +244613,8 @@ var require_utils3 = __commonJS({
     exports2.array = array2;
     var errno = require_errno();
     exports2.errno = errno;
-    var fs16 = require_fs();
-    exports2.fs = fs16;
+    var fs17 = require_fs();
+    exports2.fs = fs17;
     var path19 = require_path();
     exports2.path = path19;
     var pattern = require_pattern();
@@ -244798,12 +244798,12 @@ var require_fs2 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.createFileSystemAdapter = exports2.FILE_SYSTEM_ADAPTER = void 0;
-    var fs16 = require("fs");
+    var fs17 = require("fs");
     exports2.FILE_SYSTEM_ADAPTER = {
-      lstat: fs16.lstat,
-      stat: fs16.stat,
-      lstatSync: fs16.lstatSync,
-      statSync: fs16.statSync
+      lstat: fs17.lstat,
+      stat: fs17.stat,
+      lstatSync: fs17.lstatSync,
+      statSync: fs17.statSync
     };
     function createFileSystemAdapter(fsMethods) {
       if (fsMethods === void 0) {
@@ -244820,12 +244820,12 @@ var require_settings = __commonJS({
   "../../node_modules/.pnpm/@nodelib+fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/settings.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    var fs16 = require_fs2();
+    var fs17 = require_fs2();
     var Settings = class {
       constructor(_options = {}) {
         this._options = _options;
         this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, true);
-        this.fs = fs16.createFileSystemAdapter(this._options.fs);
+        this.fs = fs17.createFileSystemAdapter(this._options.fs);
         this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, false);
         this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
       }
@@ -244982,8 +244982,8 @@ var require_utils4 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.fs = void 0;
-    var fs16 = require_fs3();
-    exports2.fs = fs16;
+    var fs17 = require_fs3();
+    exports2.fs = fs17;
   }
 });
 
@@ -245178,14 +245178,14 @@ var require_fs4 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.createFileSystemAdapter = exports2.FILE_SYSTEM_ADAPTER = void 0;
-    var fs16 = require("fs");
+    var fs17 = require("fs");
     exports2.FILE_SYSTEM_ADAPTER = {
-      lstat: fs16.lstat,
-      stat: fs16.stat,
-      lstatSync: fs16.lstatSync,
-      statSync: fs16.statSync,
-      readdir: fs16.readdir,
-      readdirSync: fs16.readdirSync
+      lstat: fs17.lstat,
+      stat: fs17.stat,
+      lstatSync: fs17.lstatSync,
+      statSync: fs17.statSync,
+      readdir: fs17.readdir,
+      readdirSync: fs17.readdirSync
     };
     function createFileSystemAdapter(fsMethods) {
       if (fsMethods === void 0) {
@@ -245204,12 +245204,12 @@ var require_settings2 = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     var path19 = require("path");
     var fsStat = require_out();
-    var fs16 = require_fs4();
+    var fs17 = require_fs4();
     var Settings = class {
       constructor(_options = {}) {
         this._options = _options;
         this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false);
-        this.fs = fs16.createFileSystemAdapter(this._options.fs);
+        this.fs = fs17.createFileSystemAdapter(this._options.fs);
         this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path19.sep);
         this.stats = this._getValue(this._options.stats, false);
         this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
@@ -246590,16 +246590,16 @@ var require_settings4 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
-    var fs16 = require("fs");
+    var fs17 = require("fs");
     var os6 = require("os");
     var CPU_COUNT = Math.max(os6.cpus().length, 1);
     exports2.DEFAULT_FILE_SYSTEM_ADAPTER = {
-      lstat: fs16.lstat,
-      lstatSync: fs16.lstatSync,
-      stat: fs16.stat,
-      statSync: fs16.statSync,
-      readdir: fs16.readdir,
-      readdirSync: fs16.readdirSync
+      lstat: fs17.lstat,
+      lstatSync: fs17.lstatSync,
+      stat: fs17.stat,
+      statSync: fs17.statSync,
+      readdir: fs17.readdir,
+      readdirSync: fs17.readdirSync
     };
     var Settings = class {
       constructor(_options = {}) {
@@ -279303,30 +279303,30 @@ type XMLHttpRequestResponseType = "" | "arraybuffer" | "blob" | "document" | "js
           yield path20;
       }
     }
-    var fs16 = runtime.fs;
+    var fs17 = runtime.fs;
     var RealFileSystemHost = class {
       async delete(path20) {
         try {
-          await fs16.delete(path20);
+          await fs17.delete(path20);
         } catch (err) {
           throw this.#getFileNotFoundErrorIfNecessary(err, path20);
         }
       }
       deleteSync(path20) {
         try {
-          fs16.deleteSync(path20);
+          fs17.deleteSync(path20);
         } catch (err) {
           throw this.#getFileNotFoundErrorIfNecessary(err, path20);
         }
       }
       readDirSync(dirPath) {
         try {
-          const entries = fs16.readDirSync(dirPath);
+          const entries = fs17.readDirSync(dirPath);
           for (const entry of entries) {
             entry.name = FileUtils.pathJoin(dirPath, entry.name);
             if (entry.isSymlink) {
               try {
-                const info = fs16.statSync(entry.name);
+                const info = fs17.statSync(entry.name);
                 if (info != null) {
                   entry.isDirectory = info.isDirectory();
                   entry.isFile = info.isFile();
@@ -279342,84 +279342,84 @@ type XMLHttpRequestResponseType = "" | "arraybuffer" | "blob" | "document" | "js
       }
       async readFile(filePath, encoding = "utf-8") {
         try {
-          return await fs16.readFile(filePath, encoding);
+          return await fs17.readFile(filePath, encoding);
         } catch (err) {
           throw this.#getFileNotFoundErrorIfNecessary(err, filePath);
         }
       }
       readFileSync(filePath, encoding = "utf-8") {
         try {
-          return fs16.readFileSync(filePath, encoding);
+          return fs17.readFileSync(filePath, encoding);
         } catch (err) {
           throw this.#getFileNotFoundErrorIfNecessary(err, filePath);
         }
       }
       async writeFile(filePath, fileText) {
-        return fs16.writeFile(filePath, fileText);
+        return fs17.writeFile(filePath, fileText);
       }
       writeFileSync(filePath, fileText) {
-        fs16.writeFileSync(filePath, fileText);
+        fs17.writeFileSync(filePath, fileText);
       }
       mkdir(dirPath) {
-        return fs16.mkdir(dirPath);
+        return fs17.mkdir(dirPath);
       }
       mkdirSync(dirPath) {
-        fs16.mkdirSync(dirPath);
+        fs17.mkdirSync(dirPath);
       }
       move(srcPath, destPath) {
-        return fs16.move(srcPath, destPath);
+        return fs17.move(srcPath, destPath);
       }
       moveSync(srcPath, destPath) {
-        fs16.moveSync(srcPath, destPath);
+        fs17.moveSync(srcPath, destPath);
       }
       copy(srcPath, destPath) {
-        return fs16.copy(srcPath, destPath);
+        return fs17.copy(srcPath, destPath);
       }
       copySync(srcPath, destPath) {
-        fs16.copySync(srcPath, destPath);
+        fs17.copySync(srcPath, destPath);
       }
       async fileExists(filePath) {
         try {
-          return (await fs16.stat(filePath))?.isFile() ?? false;
+          return (await fs17.stat(filePath))?.isFile() ?? false;
         } catch {
           return false;
         }
       }
       fileExistsSync(filePath) {
         try {
-          return fs16.statSync(filePath)?.isFile() ?? false;
+          return fs17.statSync(filePath)?.isFile() ?? false;
         } catch {
           return false;
         }
       }
       async directoryExists(dirPath) {
         try {
-          return (await fs16.stat(dirPath))?.isDirectory() ?? false;
+          return (await fs17.stat(dirPath))?.isDirectory() ?? false;
         } catch {
           return false;
         }
       }
       directoryExistsSync(dirPath) {
         try {
-          return fs16.statSync(dirPath)?.isDirectory() ?? false;
+          return fs17.statSync(dirPath)?.isDirectory() ?? false;
         } catch {
           return false;
         }
       }
       realpathSync(path20) {
-        return fs16.realpathSync(path20);
+        return fs17.realpathSync(path20);
       }
       getCurrentDirectory() {
-        return FileUtils.standardizeSlashes(fs16.getCurrentDirectory());
+        return FileUtils.standardizeSlashes(fs17.getCurrentDirectory());
       }
       glob(patterns) {
-        return fs16.glob(backSlashesToForward(patterns));
+        return fs17.glob(backSlashesToForward(patterns));
       }
       globSync(patterns) {
-        return fs16.globSync(backSlashesToForward(patterns));
+        return fs17.globSync(backSlashesToForward(patterns));
       }
       isCaseSensitive() {
-        return fs16.isCaseSensitive();
+        return fs17.isCaseSensitive();
       }
       #getDirectoryNotFoundErrorIfNecessary(err, path20) {
         return FileUtils.isNotExistsError(err) ? new exports2.errors.DirectoryNotFoundError(FileUtils.getStandardizedAbsolutePath(this, path20)) : err;
@@ -317461,12 +317461,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs16, exportName) {
+    function addFormats(ajv, list, fs17, exportName) {
       var _a3;
       var _b;
       (_a3 = (_b = ajv.opts.code).formats) !== null && _a3 !== void 0 ? _a3 : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs16[f]);
+        ajv.addFormat(f, fs17[f]);
     }
     module3.exports = exports2 = formatsPlugin;
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -318403,6 +318403,27 @@ function jsonResponse(result) {
     ]
   };
 }
+async function catchUpWorkspaceIndex(workspaceId) {
+  const now = Date.now();
+  const current = catchupState.get(workspaceId);
+  if (current?.inFlight) {
+    await current.inFlight;
+    return;
+  }
+  if (current && now - current.lastRunAt < MCP_CATCHUP_INTERVAL_MS) {
+    return;
+  }
+  const inFlight = indexWorkspace({ workspaceId, mode: "incremental" }).then(() => void 0).catch((error2) => {
+    console.error(`OpenEZ MCP catch-up indexing failed: ${error2 instanceof Error ? error2.message : String(error2)}`);
+  }).finally(() => {
+    catchupState.set(workspaceId, { lastRunAt: Date.now() });
+  });
+  catchupState.set(workspaceId, { lastRunAt: current?.lastRunAt ?? 0, inFlight });
+  await inFlight;
+}
+async function catchUpReadWorkspaces(workspaces2) {
+  await Promise.all(workspaces2.map((workspace) => catchUpWorkspaceIndex(workspace.id)));
+}
 async function createAndStartMcpServer(options) {
   const resolver = createWorkspaceResolver(options);
   const server2 = new Server(
@@ -318514,6 +318535,7 @@ async function createAndStartMcpServer(options) {
       case "memory_query": {
         const input = memoryQuerySchema.parse(request.params.arguments ?? {});
         const workspaces2 = await resolver.resolveReadWorkspaces(input);
+        await catchUpReadWorkspaces(workspaces2);
         const results = await Promise.all(
           workspaces2.map(async (workspace) => ({
             workspace,
@@ -318548,6 +318570,7 @@ ${result.answerContext}`).join("\n\n");
       case "code_context": {
         const input = codeContextSchema.parse(request.params.arguments ?? {});
         const workspaces2 = await resolver.resolveReadWorkspaces(input);
+        await catchUpReadWorkspaces(workspaces2);
         const results = await Promise.all(
           workspaces2.map(async (workspace) => ({
             workspaceId: workspace.id,
@@ -318565,6 +318588,7 @@ ${result.answerContext}`).join("\n\n");
       case "graph_neighbors": {
         const input = graphNeighborsSchema.parse(request.params.arguments ?? {});
         const workspaces2 = await resolver.resolveReadWorkspaces(input);
+        await catchUpReadWorkspaces(workspaces2);
         const results = await Promise.all(
           workspaces2.map(async (workspace) => ({
             workspaceId: workspace.id,
@@ -318615,8 +318639,7 @@ async function autoIndexAndSync(searchRoot) {
     }
   }
   if (!workspace) {
-    workspace = await registry2.ensureWorkspace({ rootPath: resolvedRoot });
-    await writeLocalWorkspaceConfig(workspace);
+    return;
   }
   if (workspace.indexingStatus === "pending" || workspace.documentCount === 0) {
     try {
@@ -318624,6 +318647,9 @@ async function autoIndexAndSync(searchRoot) {
     } catch {
     }
   }
+  if (!WATCH_ENABLED) {
+    return;
+  }
   let debounceTimer = null;
   const watcher = esm_default.watch(resolvedRoot, {
     ignored: WATCH_IGNORE_PATTERNS,
@@ -318642,8 +318668,12 @@ async function autoIndexAndSync(searchRoot) {
   watcher.on("add", triggerReindex);
   watcher.on("change", triggerReindex);
   watcher.on("unlink", triggerReindex);
+  watcher.on("error", (error2) => {
+    console.error(`OpenEZ MCP auto-sync watcher disabled: ${error2 instanceof Error ? error2.message : String(error2)}`);
+    void watcher.close();
+  });
 }
-var import_node_fs8, import_node_path12, memoryQuerySchema, codeContextSchema, graphNeighborsSchema, memoryWriteSchema, indexWorkspaceSchema, WATCH_DEBOUNCE_MS, WATCH_IGNORE_PATTERNS;
+var import_node_fs8, import_node_path12, memoryQuerySchema, codeContextSchema, graphNeighborsSchema, memoryWriteSchema, indexWorkspaceSchema, MCP_CATCHUP_INTERVAL_MS, catchupState, WATCH_DEBOUNCE_MS, WATCH_ENABLED, WATCH_IGNORE_PATTERNS;
 var init_mcp_core = __esm({
   "../mcp/src/mcp-core.ts"() {
     "use strict";
@@ -318697,7 +318727,10 @@ var init_mcp_core = __esm({
       path: external_exports.string().optional(),
       mode: external_exports.enum(["incremental", "full"]).optional()
     });
+    MCP_CATCHUP_INTERVAL_MS = Number(process.env.OPENEZ_MCP_CATCHUP_INTERVAL_MS ?? 5e3);
+    catchupState = /* @__PURE__ */ new Map();
     WATCH_DEBOUNCE_MS = 2e3;
+    WATCH_ENABLED = ["1", "true", "yes"].includes((process.env.OPENEZ_MCP_WATCH ?? "").toLowerCase());
     WATCH_IGNORE_PATTERNS = [
       "**/node_modules/**",
       "**/.git/**",
@@ -319173,24 +319206,42 @@ function mapWorkspace2(ws) {
     updatedAt: new Date(ws.updatedAt)
   };
 }
+function resolveWebDist() {
+  const sourceDist = import_node_path14.default.resolve(__dirname, "..", "dist");
+  if ((0, import_node_fs11.existsSync)(import_node_path14.default.join(sourceDist, "index.html"))) return sourceDist;
+  const cliDist = import_node_path14.default.resolve(__dirname, "web");
+  if ((0, import_node_fs11.existsSync)(import_node_path14.default.join(cliDist, "index.html"))) return cliDist;
+  return null;
+}
 function createWebServer() {
+  const webDist = resolveWebDist();
+  if (webDist) {
+    app.use("/*", (0, import_serve_static.serveStatic)({ root: webDist, rewriteRequestPath: (p) => p }));
+    app.get("*", (c) => {
+      const indexPath = import_node_path14.default.join(webDist, "index.html");
+      const index2 = (0, import_node_fs11.readFileSync)(indexPath, "utf-8");
+      return c.html(index2);
+    });
+  }
   return app;
 }
-var import_hono, import_cors, import_node_crypto3, import_node_fs10, import_node_path14, app, DEFAULT_INCLUDE_GLOBS, DEFAULT_EXCLUDE_GLOBS;
+var import_hono, import_cors, import_serve_static, import_node_crypto3, import_node_fs10, import_node_fs11, import_node_path14, app, DEFAULT_INCLUDE_GLOBS, DEFAULT_EXCLUDE_GLOBS;
 var init_server3 = __esm({
   "../web/src/server/index.ts"() {
     "use strict";
     import_hono = require("hono");
     import_cors = require("hono/cors");
+    import_serve_static = require("@hono/node-server/serve-static");
     import_node_crypto3 = __toESM(require("crypto"), 1);
     import_node_fs10 = require("fs");
+    import_node_fs11 = require("fs");
     import_node_path14 = __toESM(require("path"), 1);
     init_sqlite2();
     init_src3();
     init_src();
     app = new import_hono.Hono();
     app.use("/*", (0, import_cors.cors)({
-      origin: ["http://localhost:5173", "http://127.0.0.1:5173", "http://localhost:17881", "http://127.0.0.1:17881"],
+      origin: ["http://localhost:5173", "http://127.0.0.1:5173", "http://localhost:11368", "http://127.0.0.1:11368"],
       credentials: true
     }));
     DEFAULT_INCLUDE_GLOBS = [
@@ -319559,6 +319610,14 @@ function resolveCliInvocation() {
     };
   }
   const repoRoot = import_node_path15.default.resolve(thisDir, "../../..");
+  const builtCliPath = import_node_path15.default.resolve(thisDir, "../dist/cli.cjs");
+  if (import_node_fs12.default.existsSync(builtCliPath)) {
+    return {
+      command: process.execPath,
+      args: [builtCliPath, "serve", "--mcp"],
+      repoRoot
+    };
+  }
   const tsxPath = import_node_path15.default.join(repoRoot, "node_modules", ".bin", "tsx");
   const cliPath = import_node_path15.default.resolve(thisDir, "./cli.ts");
   return {
@@ -319567,10 +319626,11 @@ function resolveCliInvocation() {
     repoRoot
   };
 }
-var import_node_path15, import_meta4;
+var import_node_fs12, import_node_path15, import_meta4;
 var init_resolve_cli = __esm({
   "src/resolve-cli.ts"() {
     "use strict";
+    import_node_fs12 = __toESM(require("fs"), 1);
     import_node_path15 = __toESM(require("path"), 1);
     import_meta4 = {};
   }
@@ -320489,11 +320549,11 @@ function getCodexConfigPath() {
 }
 async function setupCodex(rootPath) {
   const resolvedPath = import_node_path16.default.resolve(rootPath);
-  if (!import_node_fs11.default.existsSync(resolvedPath)) {
+  if (!import_node_fs13.default.existsSync(resolvedPath)) {
     console.error(`Error: path does not exist: ${resolvedPath}`);
     process.exit(1);
   }
-  if (!import_node_fs11.default.statSync(resolvedPath).isDirectory()) {
+  if (!import_node_fs13.default.statSync(resolvedPath).isDirectory()) {
     console.error(`Error: path is not a directory: ${resolvedPath}`);
     process.exit(1);
   }
@@ -320501,12 +320561,12 @@ async function setupCodex(rootPath) {
   const label = "openez";
   const configPath = getCodexConfigPath();
   const configDir = import_node_path16.default.dirname(configPath);
-  if (!import_node_fs11.default.existsSync(configDir)) {
-    import_node_fs11.default.mkdirSync(configDir, { recursive: true, mode: 493 });
+  if (!import_node_fs13.default.existsSync(configDir)) {
+    import_node_fs13.default.mkdirSync(configDir, { recursive: true, mode: 493 });
   }
   let config2 = {};
-  if (import_node_fs11.default.existsSync(configPath)) {
-    const raw = import_node_fs11.default.readFileSync(configPath, "utf-8");
+  if (import_node_fs13.default.existsSync(configPath)) {
+    const raw = import_node_fs13.default.readFileSync(configPath, "utf-8");
     try {
       config2 = parse3(raw);
     } catch {
@@ -320524,8 +320584,8 @@ async function setupCodex(rootPath) {
   };
   mcpServers[label] = entry;
   const output = stringify2(config2);
-  import_node_fs11.default.writeFileSync(configPath, output, "utf-8");
-  import_node_fs11.default.chmodSync(configPath, 420);
+  import_node_fs13.default.writeFileSync(configPath, output, "utf-8");
+  import_node_fs13.default.chmodSync(configPath, 420);
   console.log(`Codex MCP server configured: '${label}'`);
   console.log("  Mode:    shared multi-workspace MCP");
   console.log(`  Repo:    ${repoRoot}`);
@@ -320533,11 +320593,11 @@ async function setupCodex(rootPath) {
   console.log("");
   console.log("Restart Codex or open a new session for the changes to take effect.");
 }
-var import_node_fs11, import_node_os3, import_node_path16;
+var import_node_fs13, import_node_os3, import_node_path16;
 var init_setup_codex = __esm({
   "src/setup-codex.ts"() {
     "use strict";
-    import_node_fs11 = __toESM(require("fs"), 1);
+    import_node_fs13 = __toESM(require("fs"), 1);
     import_node_os3 = __toESM(require("os"), 1);
     import_node_path16 = __toESM(require("path"), 1);
     init_resolve_cli();
@@ -320555,11 +320615,11 @@ function getClaudeConfigPath() {
 }
 async function setupClaude(rootPath) {
   const resolvedPath = import_node_path17.default.resolve(rootPath);
-  if (!import_node_fs12.default.existsSync(resolvedPath)) {
+  if (!import_node_fs14.default.existsSync(resolvedPath)) {
     console.error(`Error: path does not exist: ${resolvedPath}`);
     process.exit(1);
   }
-  if (!import_node_fs12.default.statSync(resolvedPath).isDirectory()) {
+  if (!import_node_fs14.default.statSync(resolvedPath).isDirectory()) {
     console.error(`Error: path is not a directory: ${resolvedPath}`);
     process.exit(1);
   }
@@ -320567,12 +320627,12 @@ async function setupClaude(rootPath) {
   const label = "openez";
   const configPath = getClaudeConfigPath();
   const configDir = import_node_path17.default.dirname(configPath);
-  if (!import_node_fs12.default.existsSync(configDir)) {
-    import_node_fs12.default.mkdirSync(configDir, { recursive: true, mode: 493 });
+  if (!import_node_fs14.default.existsSync(configDir)) {
+    import_node_fs14.default.mkdirSync(configDir, { recursive: true, mode: 493 });
   }
   let config2 = {};
-  if (import_node_fs12.default.existsSync(configPath)) {
-    const raw = import_node_fs12.default.readFileSync(configPath, "utf-8");
+  if (import_node_fs14.default.existsSync(configPath)) {
+    const raw = import_node_fs14.default.readFileSync(configPath, "utf-8");
     try {
       config2 = JSON.parse(raw);
     } catch {
@@ -320588,8 +320648,8 @@ async function setupClaude(rootPath) {
     args,
     startupTimeoutSec: 120
   };
-  import_node_fs12.default.writeFileSync(configPath, JSON.stringify(config2, null, 2) + "\n", "utf-8");
-  import_node_fs12.default.chmodSync(configPath, 420);
+  import_node_fs14.default.writeFileSync(configPath, JSON.stringify(config2, null, 2) + "\n", "utf-8");
+  import_node_fs14.default.chmodSync(configPath, 420);
   console.log(`Claude Code MCP server configured: '${label}'`);
   console.log("  Mode:    shared multi-workspace MCP");
   console.log(`  Repo:    ${repoRoot}`);
@@ -320597,11 +320657,11 @@ async function setupClaude(rootPath) {
   console.log("");
   console.log("Restart Claude Code or open a new session for the changes to take effect.");
 }
-var import_node_fs12, import_node_os4, import_node_path17;
+var import_node_fs14, import_node_os4, import_node_path17;
 var init_setup_claude = __esm({
   "src/setup-claude.ts"() {
     "use strict";
-    import_node_fs12 = __toESM(require("fs"), 1);
+    import_node_fs14 = __toESM(require("fs"), 1);
     import_node_os4 = __toESM(require("os"), 1);
     import_node_path17 = __toESM(require("path"), 1);
     init_resolve_cli();
@@ -320618,11 +320678,11 @@ function getOpenCodeConfigPath() {
 }
 async function setupOpenCode(rootPath) {
   const resolvedPath = import_node_path18.default.resolve(rootPath);
-  if (!import_node_fs13.default.existsSync(resolvedPath)) {
+  if (!import_node_fs15.default.existsSync(resolvedPath)) {
     console.error(`Error: path does not exist: ${resolvedPath}`);
     process.exit(1);
   }
-  if (!import_node_fs13.default.statSync(resolvedPath).isDirectory()) {
+  if (!import_node_fs15.default.statSync(resolvedPath).isDirectory()) {
     console.error(`Error: path is not a directory: ${resolvedPath}`);
     process.exit(1);
   }
@@ -320630,12 +320690,12 @@ async function setupOpenCode(rootPath) {
   const label = "openez";
   const configPath = getOpenCodeConfigPath();
   const configDir = import_node_path18.default.dirname(configPath);
-  if (!import_node_fs13.default.existsSync(configDir)) {
-    import_node_fs13.default.mkdirSync(configDir, { recursive: true, mode: 493 });
+  if (!import_node_fs15.default.existsSync(configDir)) {
+    import_node_fs15.default.mkdirSync(configDir, { recursive: true, mode: 493 });
   }
   let config2 = {};
-  if (import_node_fs13.default.existsSync(configPath)) {
-    const raw = import_node_fs13.default.readFileSync(configPath, "utf-8");
+  if (import_node_fs15.default.existsSync(configPath)) {
+    const raw = import_node_fs15.default.readFileSync(configPath, "utf-8");
     try {
       config2 = JSON.parse(raw);
     } catch {
@@ -320650,8 +320710,8 @@ async function setupOpenCode(rootPath) {
     command,
     args
   };
-  import_node_fs13.default.writeFileSync(configPath, JSON.stringify(config2, null, 2) + "\n", "utf-8");
-  import_node_fs13.default.chmodSync(configPath, 420);
+  import_node_fs15.default.writeFileSync(configPath, JSON.stringify(config2, null, 2) + "\n", "utf-8");
+  import_node_fs15.default.chmodSync(configPath, 420);
   console.log(`OpenCode MCP server configured: '${label}'`);
   console.log("  Mode:    shared multi-workspace MCP");
   console.log(`  Repo:    ${repoRoot}`);
@@ -320659,11 +320719,11 @@ async function setupOpenCode(rootPath) {
   console.log("");
   console.log("Restart OpenCode or open a new session for the changes to take effect.");
 }
-var import_node_fs13, import_node_os5, import_node_path18;
+var import_node_fs15, import_node_os5, import_node_path18;
 var init_setup_opencode = __esm({
   "src/setup-opencode.ts"() {
     "use strict";
-    import_node_fs13 = __toESM(require("fs"), 1);
+    import_node_fs15 = __toESM(require("fs"), 1);
     import_node_os5 = __toESM(require("os"), 1);
     import_node_path18 = __toESM(require("path"), 1);
     init_resolve_cli();
@@ -320671,7 +320731,7 @@ var init_setup_opencode = __esm({
 });
 
 // src/cli.ts
-var import_node_fs14 = __toESM(require("fs"), 1);
+var import_node_fs16 = __toESM(require("fs"), 1);
 var import_node_path19 = __toESM(require("path"), 1);
 init_esm2();
 
@@ -320696,14 +320756,14 @@ var {
 init_src();
 init_src4();
 var program2 = new Command();
-program2.name("openez").description("OpenEZ Graph - Local-first knowledge retrieval system").version("0.2.0");
+program2.name("openez").description("OpenEZ Graph - Local-first knowledge retrieval system").version("0.3.0");
 program2.command("init").description("Initialize a workspace at the given path and run initial index").argument("[path]", "path to the project directory", process.cwd()).option("--no-index", "skip initial indexing").action(async (targetPath, options) => {
   const resolvedPath = import_node_path19.default.resolve(targetPath);
-  if (!import_node_fs14.default.existsSync(resolvedPath)) {
+  if (!import_node_fs16.default.existsSync(resolvedPath)) {
     console.error(`Error: path does not exist: ${resolvedPath}`);
     process.exit(1);
   }
-  if (!import_node_fs14.default.statSync(resolvedPath).isDirectory()) {
+  if (!import_node_fs16.default.statSync(resolvedPath).isDirectory()) {
     console.error(`Error: path is not a directory: ${resolvedPath}`);
     process.exit(1);
   }
@@ -320740,6 +320800,7 @@ program2.command("index").description("Index files in a workspace").argument("[p
     });
     console.log(`Auto-registered workspace '${workspace.name}' (${workspace.id})`);
   }
+  await writeLocalWorkspaceConfig(workspace);
   const summary = await indexWorkspace({ workspaceId: workspace.id });
   console.log(JSON.stringify(summary, null, 2));
 });
@@ -320751,6 +320812,7 @@ program2.command("reindex").description("Full rebuild of a workspace index").arg
     console.error(`Error: no workspace registered at ${resolvedPath}. Run 'openez init' first.`);
     process.exit(1);
   }
+  await writeLocalWorkspaceConfig(workspace);
   const summary = await indexWorkspace({ workspaceId: workspace.id, mode: "full" });
   console.log(JSON.stringify(summary, null, 2));
 });
@@ -320764,8 +320826,10 @@ program2.command("watch").description("Watch files and re-index on changes").arg
     });
     console.log(`Auto-registered workspace '${workspace.name}' (${workspace.id})`);
   }
+  await writeLocalWorkspaceConfig(workspace);
+  const workspaceId = workspace.id;
   console.log(`Running initial index for ${resolvedPath}...`);
-  await indexWorkspace({ workspaceId: workspace.id });
+  await indexWorkspace({ workspaceId });
   const watcher = esm_default.watch(resolvedPath, {
     ignored: [
       "**/node_modules/**",
@@ -320780,30 +320844,54 @@ program2.command("watch").description("Watch files and re-index on changes").arg
     ignoreInitial: true,
     persistent: true
   });
-  const reindex = async () => {
-    console.log("Change detected, re-indexing...");
-    const summary = await indexWorkspace({ workspaceId: workspace.id });
-    console.log(JSON.stringify(summary, null, 2));
+  let debounceTimer;
+  let isIndexing = false;
+  let hasPendingChange = false;
+  const runReindex = async () => {
+    if (isIndexing) {
+      hasPendingChange = true;
+      return;
+    }
+    isIndexing = true;
+    do {
+      hasPendingChange = false;
+      console.log("Change detected, re-indexing...");
+      try {
+        const summary = await indexWorkspace({ workspaceId });
+        console.log(JSON.stringify(summary, null, 2));
+      } catch (error2) {
+        console.error("Re-index failed:");
+        console.error(error2);
+      }
+    } while (hasPendingChange);
+    isIndexing = false;
+  };
+  const scheduleReindex = () => {
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+    debounceTimer = setTimeout(() => {
+      void runReindex();
+    }, 250);
   };
-  watcher.on("add", reindex);
-  watcher.on("change", reindex);
-  watcher.on("unlink", reindex);
+  watcher.on("add", scheduleReindex);
+  watcher.on("change", scheduleReindex);
+  watcher.on("unlink", scheduleReindex);
   console.log(`Watching ${resolvedPath} for changes...`);
 });
-program2.command("serve").description("Start the web dashboard or MCP server").option("--mcp", "run as MCP server instead of web").option("--web", "start the web dashboard API server").option("-p, --path <path>", "workspace path").option("--port <port>", "API server port (default: 17881)").action(async (options) => {
+program2.command("serve").description("Start the web dashboard or MCP server").option("--mcp", "run as MCP server instead of web").option("--web", "start the web dashboard API server").option("-p, --path <path>", "workspace path").option("--port <port>", "API server port (default: 11368)").action(async (options) => {
   if (options.mcp) {
     const { startMcpServer: startMcpServer2 } = await Promise.resolve().then(() => (init_mcp_bridge(), mcp_bridge_exports));
     await startMcpServer2(options.path ? import_node_path19.default.resolve(options.path) : void 0);
   } else if (options.web) {
-    const port = options.port ? Number(options.port) : Number(process.env.API_PORT ?? 17881);
+    const port = options.port ? Number(options.port) : Number(process.env.API_PORT ?? 11368);
     process.env.API_PORT = String(port);
     const { serve } = await import("@hono/node-server");
     const { createWebServer: createWebServer2 } = await Promise.resolve().then(() => (init_web_server(), web_server_exports));
     const app2 = createWebServer2();
     serve({ fetch: app2.fetch, port }, (info) => {
       console.log(`OpenEZ Graph web dashboard:`);
-      console.log(`  API:   http://localhost:${info.port}`);
-      console.log(`  Frontend: http://localhost:5173 (run 'pnpm dev:web' separately)`);
+      console.log(`  http://localhost:${info.port}`);
       console.log(`  Press Ctrl+C to stop`);
     });
   } else {