rrce-workflow 0.2.92 → 0.2.93

package/dist/index.js

@@ -1562,6 +1562,33 @@ var init_rag = __esm({
           logger.error(`[RAG] Failed to save index to ${this.indexPath}`, error);
         }
       }
+      /**
+       * Save index to a temp file and atomically replace
+       */
+      saveIndexAtomic() {
+        if (!this.index) return;
+        const dir = path15.dirname(this.indexPath);
+        if (!fs13.existsSync(dir)) {
+          fs13.mkdirSync(dir, { recursive: true });
+        }
+        const tmpPath = `${this.indexPath}.tmp`;
+        fs13.writeFileSync(tmpPath, JSON.stringify(this.index, null, 2));
+        fs13.renameSync(tmpPath, this.indexPath);
+      }
+      /**
+       * Save index only if enough time passed since last save
+       */
+      maybeSaveIndex(force = false) {
+        if (!this.index) return;
+        const now = Date.now();
+        const intervalMs = 1e3;
+        const last = this.index.metadata?.lastSaveAt;
+        if (force || last === void 0 || now - last >= intervalMs) {
+          this.index.metadata = { ...this.index.metadata ?? {}, lastSaveAt: now };
+          this.saveIndexAtomic();
+          logger.info(`[RAG] Saved index (atomic) to ${this.indexPath} with ${this.index.chunks.length} chunks.`);
+        }
+      }
       /**
        * Generate embedding for text
        */
@@ -1612,7 +1639,7 @@ var init_rag = __esm({
           mtime: mtime ?? Date.now(),
           chunkCount: chunks.length
         };
-        this.saveIndex();
+        this.maybeSaveIndex();
         return true;
       }
       /**
@@ -1628,7 +1655,7 @@ var init_rag = __esm({
         }
         if (this.index.chunks.length !== initialCount) {
           logger.info(`[RAG] Removed file ${filePath} from index (${initialCount - this.index.chunks.length} chunks removed)`);
-          this.saveIndex();
+          this.maybeSaveIndex(true);
         }
       }
       /**
@@ -1651,7 +1678,7 @@ var init_rag = __esm({
         this.loadIndex();
         if (!this.index) return;
         this.index.lastFullIndex = Date.now();
-        this.saveIndex();
+        this.maybeSaveIndex(true);
       }
       /**
        * Search the index
@@ -1681,9 +1708,11 @@ var init_rag = __esm({
         let normA = 0;
         let normB = 0;
         for (let i = 0; i < a.length; i++) {
-          dotProduct += a[i] * b[i];
-          normA += a[i] * a[i];
-          normB += b[i] * b[i];
+          const av = a[i] ?? 0;
+          const bv = b[i] ?? 0;
+          dotProduct += av * bv;
+          normA += av * av;
+          normB += bv * bv;
         }
         return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
       }
@@ -1716,6 +1745,83 @@ var init_rag = __esm({
   }
 });
 
+// src/mcp/services/indexing-jobs.ts
+var IndexingJobManager, indexingJobs;
+var init_indexing_jobs = __esm({
+  "src/mcp/services/indexing-jobs.ts"() {
+    "use strict";
+    init_logger();
+    IndexingJobManager = class {
+      jobs = /* @__PURE__ */ new Map();
+      getProgress(project) {
+        const existing = this.jobs.get(project);
+        if (existing) return { ...existing.progress };
+        return {
+          project,
+          state: "idle",
+          itemsDone: 0,
+          itemsTotal: void 0
+        };
+      }
+      update(project, patch) {
+        const existing = this.jobs.get(project);
+        const next = {
+          ...existing?.progress ?? this.getProgress(project),
+          ...patch,
+          project
+        };
+        this.jobs.set(project, { ...existing ?? { progress: next }, progress: next });
+      }
+      isRunning(project) {
+        return this.getProgress(project).state === "running";
+      }
+      startOrStatus(project, runner) {
+        const current = this.jobs.get(project);
+        if (current?.progress.state === "running" && current.promise) {
+          return {
+            status: "already_running",
+            state: "running",
+            progress: { ...current.progress }
+          };
+        }
+        const startedAt = Date.now();
+        const initial = {
+          project,
+          state: "running",
+          startedAt,
+          itemsDone: 0,
+          itemsTotal: void 0,
+          currentItem: void 0,
+          lastError: void 0
+        };
+        const job = { progress: initial };
+        this.jobs.set(project, job);
+        job.promise = (async () => {
+          try {
+            await runner();
+            this.update(project, { state: "complete", completedAt: Date.now(), currentItem: void 0 });
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.error(`[RAG] Indexing job failed for '${project}'`, err);
+            this.update(project, {
+              state: "failed",
+              completedAt: Date.now(),
+              currentItem: void 0,
+              lastError: msg
+            });
+          }
+        })();
+        return {
+          status: "started",
+          state: "running",
+          progress: { ...this.getProgress(project) }
+        };
+      }
+    };
+    indexingJobs = new IndexingJobManager();
+  }
+});
+
 // src/mcp/resources.ts
 import * as fs14 from "fs";
 import * as path16 from "path";
@@ -1887,6 +1993,8 @@ async function searchKnowledge(query, projectFilter) {
     if (projectFilter && project.name !== projectFilter) continue;
     const permissions = getProjectPermissions(config, project.name, project.sourcePath || project.path);
     if (!permissions.knowledge || !project.knowledgePath) continue;
+    const indexingInProgress = indexingJobs.isRunning(project.name);
+    const advisoryMessage = indexingInProgress ? "Indexing in progress; results may be stale/incomplete." : void 0;
     const projConfig = config.projects.find(
       (p) => p.path && normalizeProjectPath(p.path) === normalizeProjectPath(project.sourcePath || project.path) || !p.path && p.name === project.name
     );
@@ -1903,7 +2011,9 @@ async function searchKnowledge(query, projectFilter) {
             file: path16.relative(project.knowledgePath, r.filePath),
             matches: [r.content],
             // The chunk content is the match
-            score: r.score
+            score: r.score,
+            indexingInProgress: indexingInProgress || void 0,
+            advisoryMessage
           });
         }
         continue;
@@ -1928,8 +2038,10 @@ async function searchKnowledge(query, projectFilter) {
           results.push({
             project: project.name,
             file,
-            matches: matches.slice(0, 5)
+            matches: matches.slice(0, 5),
             // Limit to 5 matches per file
+            indexingInProgress: indexingInProgress || void 0,
+            advisoryMessage
           });
         }
       }
@@ -1941,20 +2053,44 @@ async function searchKnowledge(query, projectFilter) {
 async function indexKnowledge(projectName, force = false) {
   const config = loadMCPConfig();
   const projects = getExposedProjects();
-  const project = projects.find((p) => p.name === projectName || p.path && p.path === projectName);
+  const project = projects.find((p2) => p2.name === projectName || p2.path && p2.path === projectName);
   if (!project) {
-    return { success: false, message: `Project '${projectName}' not found`, filesIndexed: 0, filesSkipped: 0 };
+    return {
+      state: "failed",
+      status: "failed",
+      success: false,
+      message: `Project '${projectName}' not found`,
+      filesIndexed: 0,
+      filesSkipped: 0,
+      progress: { itemsDone: 0 }
+    };
   }
   const projConfig = config.projects.find(
-    (p) => p.path && normalizeProjectPath(p.path) === normalizeProjectPath(project.sourcePath || project.path) || !p.path && p.name === project.name
+    (p2) => p2.path && normalizeProjectPath(p2.path) === normalizeProjectPath(project.sourcePath || project.path) || !p2.path && p2.name === project.name
   ) || (project.source === "global" ? { semanticSearch: { enabled: true, model: "Xenova/all-MiniLM-L6-v2" } } : void 0);
   const isEnabled = projConfig?.semanticSearch?.enabled || project.semanticSearchEnabled;
   if (!isEnabled) {
-    return { success: false, message: "Semantic Search is not enabled for this project", filesIndexed: 0, filesSkipped: 0 };
+    return {
+      state: "failed",
+      status: "failed",
+      success: false,
+      message: "Semantic Search is not enabled for this project",
+      filesIndexed: 0,
+      filesSkipped: 0,
+      progress: { itemsDone: 0 }
+    };
   }
   const scanRoot = project.sourcePath || project.path || project.dataPath;
   if (!fs14.existsSync(scanRoot)) {
-    return { success: false, message: "Project root not found", filesIndexed: 0, filesSkipped: 0 };
+    return {
+      state: "failed",
+      status: "failed",
+      success: false,
+      message: "Project root not found",
+      filesIndexed: 0,
+      filesSkipped: 0,
+      progress: { itemsDone: 0 }
+    };
   }
   const INDEXABLE_EXTENSIONS = [
     ".ts",
@@ -1995,18 +2131,37 @@ async function indexKnowledge(projectName, force = false) {
     ".less"
   ];
   const SKIP_DIRS = ["node_modules", ".git", "dist", "build", ".next", "__pycache__", "venv", ".venv", "target", "vendor"];
-  try {
+  const runIndexing = async () => {
     const indexPath = path16.join(project.knowledgePath || path16.join(scanRoot, ".rrce-workflow", "knowledge"), "embeddings.json");
     const model = projConfig?.semanticSearch?.model || "Xenova/all-MiniLM-L6-v2";
     const rag = new RAGService(indexPath, model);
     let indexed = 0;
     let skipped = 0;
+    let itemsTotal = 0;
+    let itemsDone = 0;
+    const shouldSkipDir = (dirName) => SKIP_DIRS.includes(dirName) || dirName.startsWith(".");
+    const preCount = (dir) => {
+      const entries = fs14.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path16.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          if (shouldSkipDir(entry.name)) continue;
+          preCount(fullPath);
+        } else if (entry.isFile()) {
+          const ext = path16.extname(entry.name).toLowerCase();
+          if (!INDEXABLE_EXTENSIONS.includes(ext)) continue;
+          itemsTotal++;
+        }
+      }
+    };
+    preCount(scanRoot);
+    indexingJobs.update(project.name, { itemsTotal });
     const scanDir = async (dir) => {
       const entries = fs14.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
         const fullPath = path16.join(dir, entry.name);
         if (entry.isDirectory()) {
-          if (SKIP_DIRS.includes(entry.name) || entry.name.startsWith(".")) {
+          if (shouldSkipDir(entry.name)) {
             continue;
           }
           await scanDir(fullPath);
@@ -2016,6 +2171,7 @@ async function indexKnowledge(projectName, force = false) {
             continue;
           }
           try {
+            indexingJobs.update(project.name, { currentItem: fullPath, itemsDone });
             const stat = fs14.statSync(fullPath);
             const mtime = force ? void 0 : stat.mtimeMs;
             const content = fs14.readFileSync(fullPath, "utf-8");
@@ -2026,6 +2182,12 @@ async function indexKnowledge(projectName, force = false) {
               skipped++;
             }
           } catch (err) {
+          } finally {
+            itemsDone++;
+            indexingJobs.update(project.name, { itemsDone });
+            if (itemsDone % 10 === 0) {
+              await new Promise((resolve2) => setImmediate(resolve2));
+            }
           }
         }
       }
@@ -2033,15 +2195,28 @@ async function indexKnowledge(projectName, force = false) {
     await scanDir(scanRoot);
     rag.markFullIndex();
     const stats = rag.getStats();
-    return {
-      success: true,
-      message: `Indexed ${indexed} files, skipped ${skipped} unchanged. Total: ${stats.totalChunks} chunks from ${stats.totalFiles} files.`,
-      filesIndexed: indexed,
-      filesSkipped: skipped
-    };
-  } catch (error) {
-    return { success: false, message: `Indexing failed: ${error}`, filesIndexed: 0, filesSkipped: 0 };
-  }
+    const message = `Indexed ${indexed} files, skipped ${skipped} unchanged. Total: ${stats.totalChunks} chunks from ${stats.totalFiles} files.`;
+    logger.info(`[RAG] ${project.name}: ${message}`);
+    indexingJobs.update(project.name, { currentItem: void 0 });
+  };
+  const startResult = indexingJobs.startOrStatus(project.name, runIndexing);
+  const p = startResult.progress;
+  return {
+    state: startResult.state,
+    status: startResult.status,
+    success: startResult.status === "started" || startResult.status === "already_running",
+    message: startResult.status === "started" ? `Indexing started in background for '${project.name}'.` : `Indexing already running for '${project.name}'.`,
+    filesIndexed: 0,
+    filesSkipped: 0,
+    progress: {
+      itemsDone: p.itemsDone,
+      itemsTotal: p.itemsTotal,
+      currentItem: p.currentItem,
+      startedAt: p.startedAt,
+      completedAt: p.completedAt,
+      lastError: p.lastError
+    }
+  };
 }
 function getContextPreamble() {
   const projects = getExposedProjects();
@@ -2189,6 +2364,7 @@ var init_resources = __esm({
     init_detection();
     init_detection_service();
     init_rag();
+    init_indexing_jobs();
     init_paths();
   }
 });
@@ -3440,6 +3616,7 @@ var IndexingStatus;
 var init_IndexingStatus = __esm({
   "src/mcp/ui/IndexingStatus.tsx"() {
     "use strict";
+    init_indexing_jobs();
     init_rag();
     init_resources();
     init_config_utils();
@@ -3456,9 +3633,14 @@ var init_IndexingStatus = __esm({
             }
             const enabled = projConfig?.semanticSearch?.enabled || project.semanticSearchEnabled || false;
             if (!enabled) {
+              const prog = indexingJobs.getProgress(project.name);
               newStats.push({
                 projectName: project.name,
                 enabled: false,
+                state: prog.state,
+                itemsDone: prog.itemsDone,
+                itemsTotal: prog.itemsTotal,
+                currentItem: prog.currentItem,
                 totalFiles: 0,
                 totalChunks: 0
               });
@@ -3468,17 +3650,27 @@ var init_IndexingStatus = __esm({
               const indexPath = getRAGIndexPath(project);
               const rag = new RAGService(indexPath, "dummy");
               const s = rag.getStats();
+              const prog = indexingJobs.getProgress(project.name);
               newStats.push({
                 projectName: project.name,
                 enabled: true,
+                state: prog.state,
+                itemsDone: prog.itemsDone,
+                itemsTotal: prog.itemsTotal,
+                currentItem: prog.currentItem,
                 totalFiles: s.totalFiles,
                 totalChunks: s.totalChunks,
                 lastFullIndex: s.lastFullIndex
               });
             } catch (e) {
+              const prog = indexingJobs.getProgress(project.name);
               newStats.push({
                 projectName: project.name,
                 enabled: true,
+                state: prog.state,
+                itemsDone: prog.itemsDone,
+                itemsTotal: prog.itemsTotal,
+                currentItem: prog.currentItem,
                 totalFiles: 0,
                 totalChunks: 0,
                 error: String(e)
@@ -3501,13 +3693,16 @@ var init_IndexingStatus = __esm({
           /* @__PURE__ */ jsxs8(Box9, { children: [
             /* @__PURE__ */ jsx9(Box9, { width: 25, children: /* @__PURE__ */ jsx9(Text9, { underline: true, children: "Project" }) }),
             /* @__PURE__ */ jsx9(Box9, { width: 15, children: /* @__PURE__ */ jsx9(Text9, { underline: true, children: "Status" }) }),
+            /* @__PURE__ */ jsx9(Box9, { width: 15, children: /* @__PURE__ */ jsx9(Text9, { underline: true, children: "State" }) }),
+            /* @__PURE__ */ jsx9(Box9, { width: 18, children: /* @__PURE__ */ jsx9(Text9, { underline: true, children: "Progress" }) }),
             /* @__PURE__ */ jsx9(Box9, { width: 15, children: /* @__PURE__ */ jsx9(Text9, { underline: true, children: "Indexed Files" }) }),
             /* @__PURE__ */ jsx9(Box9, { width: 15, children: /* @__PURE__ */ jsx9(Text9, { underline: true, children: "Total Chunks" }) }),
             /* @__PURE__ */ jsx9(Box9, { children: /* @__PURE__ */ jsx9(Text9, { underline: true, children: "Last Index" }) })
           ] }),
           stats.length === 0 ? /* @__PURE__ */ jsx9(Text9, { color: "dim", children: "No exposed projects found." }) : stats.map((s) => /* @__PURE__ */ jsxs8(Box9, { marginTop: 0, children: [
             /* @__PURE__ */ jsx9(Box9, { width: 25, children: /* @__PURE__ */ jsx9(Text9, { color: "white", children: s.projectName }) }),
-            /* @__PURE__ */ jsx9(Box9, { width: 15, children: /* @__PURE__ */ jsx9(Text9, { color: s.enabled ? "green" : "dim", children: s.enabled ? "Enabled" : "Disabled" }) }),
+            /* @__PURE__ */ jsx9(Box9, { width: 15, children: /* @__PURE__ */ jsx9(Text9, { color: s.state === "running" ? "yellow" : s.state === "failed" ? "red" : s.enabled ? "green" : "dim", children: s.enabled ? s.state : "disabled" }) }),
+            /* @__PURE__ */ jsx9(Box9, { width: 18, children: /* @__PURE__ */ jsx9(Text9, { children: s.state === "running" ? `${s.itemsDone}/${s.itemsTotal ?? "?"}` : "-" }) }),
             /* @__PURE__ */ jsx9(Box9, { width: 15, children: /* @__PURE__ */ jsx9(Text9, { children: s.enabled ? s.totalFiles : "-" }) }),
             /* @__PURE__ */ jsx9(Box9, { width: 15, children: /* @__PURE__ */ jsx9(Text9, { children: s.enabled ? s.totalChunks : "-" }) }),
             /* @__PURE__ */ jsx9(Box9, { children: /* @__PURE__ */ jsx9(Text9, { children: s.lastFullIndex ? new Date(s.lastFullIndex).toLocaleTimeString() : "-" }) })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rrce-workflow",
-  "version": "0.2.92",
+  "version": "0.2.93",
   "description": "RRCE-Workflow TUI - Agentic code workflow generator for AI-assisted development",
   "author": "RRCE Team",
   "license": "MIT",