rrce-workflow 0.3.20 → 0.3.22

package/agent-core/prompts/sync.md

@@ -33,14 +33,15 @@ Non-Negotiables
 3. Version every knowledge edit by stamping an ISO date (e.g. `Updated: 2024-11-01`) near the top of the section you modify.
 4. Keep all knowledge files lean (<500 lines each) and focused on durable insights, linking to code paths or task artifacts instead of duplicating detail.
 5. Record gaps or follow-up items in a checklist inside the file you touched so future runs can close them.
-6. **Semantic Indexing (MANDATORY)**: After updating any knowledge files, run the indexer to keep search current:
-   ```
-   Tool: rrce_index_knowledge
-   Args: { "project": "{{WORKSPACE_NAME}}" }
-   ```
-   Tool: rrce_index_knowledge
-   Args: { "project": "{{WORKSPACE_NAME}}" }
-   ```
+6. **Semantic Indexing (MANDATORY)**: After updating any knowledge files, run the indexer to keep search current.
+
+## Reindexing Guidance
+
+| Scenario | Tool Argument | Rationale |
+|----------|---------------|-----------|
+| Routine updates | `{ "project": "{{WORKSPACE_NAME}}" }` | Incremental (fastest). Only updates changed files. |
+| Major refactors | `{ "project": "{{WORKSPACE_NAME}}", "force": true }` | Forces re-calculation of hashes for all files without wiping. |
+| Corrupt index / Stale vectors | `{ "project": "{{WORKSPACE_NAME}}", "clean": true }` | Wipes index files and rebuilds from scratch. Resolves vector drift. |
 
 Deliverable
 - Updated `{{RRCE_DATA}}/knowledge/*` files that accurately reflect the present project state, each carrying the latest `Updated:` marker and lean checklist.

package/dist/index.js

@@ -1232,8 +1232,6 @@ ${prompt.content}` : prompt.content;
       if (fs7.existsSync(openCodeConfig)) {
         const config = JSON.parse(fs7.readFileSync(openCodeConfig, "utf8"));
         if (!config.agent) config.agent = {};
-        if (!config.agent.plan) config.agent.plan = {};
-        config.agent.plan.disable = true;
         fs7.writeFileSync(openCodeConfig, JSON.stringify(config, null, 2));
       }
     } catch (e) {
@@ -3597,10 +3595,126 @@ var init_search = __esm({
   }
 });
 
-// src/mcp/resources/indexing.ts
+// src/lib/drift-service.ts
 import * as fs20 from "fs";
 import * as path21 from "path";
-async function indexKnowledge(projectName, force = false) {
+import * as crypto2 from "crypto";
+var DriftService;
+var init_drift_service = __esm({
+  "src/lib/drift-service.ts"() {
+    "use strict";
+    DriftService = class {
+      static CHECKSUM_FILENAME = ".rrce-checksums.json";
+      static calculateHash(filePath) {
+        const content = fs20.readFileSync(filePath);
+        return crypto2.createHash("md5").update(content).digest("hex");
+      }
+      static getManifestPath(projectPath) {
+        return path21.join(projectPath, this.CHECKSUM_FILENAME);
+      }
+      static loadManifest(projectPath) {
+        const manifestPath = this.getManifestPath(projectPath);
+        if (!fs20.existsSync(manifestPath)) {
+          return {};
+        }
+        try {
+          return JSON.parse(fs20.readFileSync(manifestPath, "utf8"));
+        } catch (e) {
+          return {};
+        }
+      }
+      static saveManifest(projectPath, manifest) {
+        const manifestPath = this.getManifestPath(projectPath);
+        fs20.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+      }
+      /**
+       * Generates a manifest for the current state of files in the project
+       */
+      static generateManifest(projectPath, files) {
+        const manifest = {};
+        for (const file of files) {
+          const fullPath = path21.join(projectPath, file);
+          if (fs20.existsSync(fullPath)) {
+            const stats = fs20.statSync(fullPath);
+            manifest[file] = {
+              hash: this.calculateHash(fullPath),
+              mtime: stats.mtimeMs
+            };
+          }
+        }
+        return manifest;
+      }
+      /**
+       * Compares current files against the manifest to detect modifications and deletions
+       */
+      static detectModifiedFiles(projectPath) {
+        const manifest = this.loadManifest(projectPath);
+        const modified = [];
+        const deleted = [];
+        for (const [relPath, entry] of Object.entries(manifest)) {
+          const fullPath = path21.join(projectPath, relPath);
+          if (!fs20.existsSync(fullPath)) {
+            deleted.push(relPath);
+            continue;
+          }
+          const stats = fs20.statSync(fullPath);
+          if (stats.mtimeMs === entry.mtime) {
+            continue;
+          }
+          const currentHash = this.calculateHash(fullPath);
+          if (currentHash !== entry.hash) {
+            modified.push(relPath);
+          }
+        }
+        return { modified, deleted };
+      }
+      /**
+       * Returns array of deleted file paths from manifest
+       */
+      static detectDeletedFiles(projectPath) {
+        const manifest = this.loadManifest(projectPath);
+        const deleted = [];
+        for (const relPath of Object.keys(manifest)) {
+          const fullPath = path21.join(projectPath, relPath);
+          if (!fs20.existsSync(fullPath)) {
+            deleted.push(relPath);
+          }
+        }
+        return deleted;
+      }
+      /**
+       * Full drift check: version + modifications
+       */
+      static checkDrift(projectPath, currentVersion, runningVersion) {
+        const { modified, deleted } = this.detectModifiedFiles(projectPath);
+        let type = "none";
+        let hasDrift = false;
+        if (currentVersion !== runningVersion) {
+          hasDrift = true;
+          type = "version";
+        } else if (modified.length > 0 || deleted.length > 0) {
+          hasDrift = true;
+          type = "modified";
+        }
+        return {
+          hasDrift,
+          type,
+          modifiedFiles: modified,
+          deletedFiles: deleted,
+          version: {
+            current: currentVersion || "0.0.0",
+            running: runningVersion
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/mcp/resources/indexing.ts
+import * as fs21 from "fs";
+import * as path22 from "path";
+async function indexKnowledge(projectName, force = false, clean = false) {
   const config = loadMCPConfig();
   const projects = getExposedProjects();
   const project = projects.find((p2) => p2.name === projectName || p2.path && p2.path === projectName);
@@ -3629,7 +3743,7 @@ async function indexKnowledge(projectName, force = false) {
     };
   }
   const scanRoot = project.sourcePath || project.path || project.dataPath;
-  if (!fs20.existsSync(scanRoot)) {
+  if (!fs21.existsSync(scanRoot)) {
     return {
       state: "failed",
       status: "failed",
@@ -3642,8 +3756,14 @@ async function indexKnowledge(projectName, force = false) {
   }
   const runIndexing = async () => {
     const { shouldSkipEntryDir, shouldSkipEntryFile } = getScanContext(project, scanRoot);
-    const indexPath = path21.join(project.knowledgePath || path21.join(scanRoot, ".rrce-workflow", "knowledge"), "embeddings.json");
-    const codeIndexPath = path21.join(project.knowledgePath || path21.join(scanRoot, ".rrce-workflow", "knowledge"), "code-embeddings.json");
+    const knowledgeDir = project.knowledgePath || path22.join(scanRoot, ".rrce-workflow", "knowledge");
+    const indexPath = path22.join(knowledgeDir, "embeddings.json");
+    const codeIndexPath = path22.join(knowledgeDir, "code-embeddings.json");
+    if (clean) {
+      logger.info(`[RAG] Cleaning knowledge index for ${project.name}`);
+      if (fs21.existsSync(indexPath)) fs21.unlinkSync(indexPath);
+      if (fs21.existsSync(codeIndexPath)) fs21.unlinkSync(codeIndexPath);
+    }
     const model = projConfig?.semanticSearch?.model || "Xenova/all-MiniLM-L6-v2";
     const rag = new RAGService(indexPath, model);
     const codeRag = new RAGService(codeIndexPath, model);
@@ -3653,14 +3773,14 @@ async function indexKnowledge(projectName, force = false) {
     let itemsTotal = 0;
     let itemsDone = 0;
     const preCount = (dir) => {
-      const entries = fs20.readdirSync(dir, { withFileTypes: true });
+      const entries = fs21.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path21.join(dir, entry.name);
+        const fullPath = path22.join(dir, entry.name);
         if (entry.isDirectory()) {
           if (shouldSkipEntryDir(fullPath)) continue;
           preCount(fullPath);
         } else if (entry.isFile()) {
-          const ext = path21.extname(entry.name).toLowerCase();
+          const ext = path22.extname(entry.name).toLowerCase();
           if (!INDEXABLE_EXTENSIONS.includes(ext)) continue;
           if (shouldSkipEntryFile(fullPath)) continue;
           itemsTotal++;
@@ -3672,13 +3792,18 @@ async function indexKnowledge(projectName, force = false) {
     const cleanupIgnoredFiles = async () => {
       const indexedFiles = [...rag.getIndexedFiles(), ...codeRag.getIndexedFiles()];
       const unique = Array.from(new Set(indexedFiles));
+      const deletedFiles = project.dataPath ? DriftService.detectDeletedFiles(project.dataPath) : [];
+      if (deletedFiles.length > 0) {
+        logger.info(`[RAG] ${project.name}: Detected ${deletedFiles.length} deleted files from manifest`);
+      }
       for (const filePath of unique) {
-        if (!path21.isAbsolute(filePath)) continue;
-        const relFilePath = filePath.split(path21.sep).join("/");
-        const relScanRoot = scanRoot.split(path21.sep).join("/");
+        if (!path22.isAbsolute(filePath)) continue;
+        const relFilePath = filePath.split(path22.sep).join("/");
+        const relScanRoot = scanRoot.split(path22.sep).join("/");
         const isInScanRoot = relFilePath === relScanRoot || relFilePath.startsWith(`${relScanRoot}/`);
         if (!isInScanRoot) continue;
-        if (shouldSkipEntryFile(filePath)) {
+        const isDeleted = deletedFiles.some((df) => filePath.endsWith(df));
+        if (shouldSkipEntryFile(filePath) || isDeleted || !fs21.existsSync(filePath)) {
           await rag.removeFile(filePath);
           await codeRag.removeFile(filePath);
         }
@@ -3686,21 +3811,21 @@ async function indexKnowledge(projectName, force = false) {
     };
     await cleanupIgnoredFiles();
     const scanDir = async (dir) => {
-      const entries = fs20.readdirSync(dir, { withFileTypes: true });
+      const entries = fs21.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path21.join(dir, entry.name);
+        const fullPath = path22.join(dir, entry.name);
         if (entry.isDirectory()) {
           if (shouldSkipEntryDir(fullPath)) continue;
           await scanDir(fullPath);
         } else if (entry.isFile()) {
-          const ext = path21.extname(entry.name).toLowerCase();
+          const ext = path22.extname(entry.name).toLowerCase();
           if (!INDEXABLE_EXTENSIONS.includes(ext)) continue;
           if (shouldSkipEntryFile(fullPath)) continue;
           try {
             indexingJobs.update(project.name, { currentItem: fullPath, itemsDone });
-            const stat = fs20.statSync(fullPath);
+            const stat = fs21.statSync(fullPath);
             const mtime = force ? void 0 : stat.mtimeMs;
-            const content = fs20.readFileSync(fullPath, "utf-8");
+            const content = fs21.readFileSync(fullPath, "utf-8");
             const wasIndexed = await rag.indexFile(fullPath, content, mtime);
             if (wasIndexed) {
               indexed++;
@@ -3772,11 +3897,12 @@ var init_indexing = __esm({
     init_projects();
     init_utils2();
     init_constants();
+    init_drift_service();
   }
 });
 
 // src/mcp/resources/context.ts
-import * as path22 from "path";
+import * as path23 from "path";
 import * as os4 from "os";
 function getContextPreamble() {
   const activeProject = detectActiveProject();
@@ -3792,7 +3918,7 @@ If the above tools fail, ask the user for clarification.
 ---
 `;
   }
-  const rrceHome = process.env.RRCE_HOME || path22.join(os4.homedir(), ".rrce-workflow");
+  const rrceHome = process.env.RRCE_HOME || path23.join(os4.homedir(), ".rrce-workflow");
   const workspaceRoot = activeProject.sourcePath || activeProject.path || activeProject.dataPath;
   const rrceData = activeProject.dataPath;
   return `## System Context
@@ -4087,8 +4213,8 @@ var init_validation = __esm({
 });
 
 // src/mcp/resources/sessions.ts
-import * as fs21 from "fs";
-import * as path23 from "path";
+import * as fs22 from "fs";
+import * as path24 from "path";
 function startSession(projectName, taskSlug, agent, phase) {
   const config = loadMCPConfig();
   const projects = projectService.scan();
@@ -4096,8 +4222,8 @@ function startSession(projectName, taskSlug, agent, phase) {
   if (!project || !project.tasksPath) {
     return { success: false, message: `Project '${projectName}' not found or not exposed.` };
   }
-  const taskDir = path23.join(project.tasksPath, taskSlug);
-  if (!fs21.existsSync(taskDir)) {
+  const taskDir = path24.join(project.tasksPath, taskSlug);
+  if (!fs22.existsSync(taskDir)) {
     return { success: false, message: `Task '${taskSlug}' not found.` };
   }
   const session = {
@@ -4107,8 +4233,8 @@ function startSession(projectName, taskSlug, agent, phase) {
     started_at: (/* @__PURE__ */ new Date()).toISOString(),
     heartbeat: (/* @__PURE__ */ new Date()).toISOString()
   };
-  const sessionPath = path23.join(taskDir, "session.json");
-  fs21.writeFileSync(sessionPath, JSON.stringify(session, null, 2));
+  const sessionPath = path24.join(taskDir, "session.json");
+  fs22.writeFileSync(sessionPath, JSON.stringify(session, null, 2));
   return { success: true, message: `Session started for ${agent} agent on task '${taskSlug}' (phase: ${phase})` };
 }
 function endSession(projectName, taskSlug) {
@@ -4118,11 +4244,11 @@ function endSession(projectName, taskSlug) {
   if (!project || !project.tasksPath) {
     return { success: false, message: `Project '${projectName}' not found or not exposed.` };
   }
-  const sessionPath = path23.join(project.tasksPath, taskSlug, "session.json");
-  if (!fs21.existsSync(sessionPath)) {
+  const sessionPath = path24.join(project.tasksPath, taskSlug, "session.json");
+  if (!fs22.existsSync(sessionPath)) {
     return { success: true, message: `No active session for task '${taskSlug}'.` };
   }
-  fs21.unlinkSync(sessionPath);
+  fs22.unlinkSync(sessionPath);
   return { success: true, message: `Session ended for task '${taskSlug}'.` };
 }
 function updateAgentTodos(projectName, taskSlug, phase, agent, items) {
@@ -4132,9 +4258,9 @@ function updateAgentTodos(projectName, taskSlug, phase, agent, items) {
   if (!project || !project.tasksPath) {
     return { success: false, message: `Project '${projectName}' not found or not exposed.` };
   }
-  const taskDir = path23.join(project.tasksPath, taskSlug);
-  if (!fs21.existsSync(taskDir)) {
-    fs21.mkdirSync(taskDir, { recursive: true });
+  const taskDir = path24.join(project.tasksPath, taskSlug);
+  if (!fs22.existsSync(taskDir)) {
+    fs22.mkdirSync(taskDir, { recursive: true });
   }
   const todos = {
     phase,
@@ -4142,8 +4268,8 @@ function updateAgentTodos(projectName, taskSlug, phase, agent, items) {
     items,
     updated_at: (/* @__PURE__ */ new Date()).toISOString()
   };
-  const todosPath = path23.join(taskDir, "agent-todos.json");
-  fs21.writeFileSync(todosPath, JSON.stringify(todos, null, 2));
+  const todosPath = path24.join(taskDir, "agent-todos.json");
+  fs22.writeFileSync(todosPath, JSON.stringify(todos, null, 2));
   return { success: true, message: `Updated ${items.length} todo items for task '${taskSlug}'.`, count: items.length };
 }
 var init_sessions = __esm({
@@ -4264,15 +4390,15 @@ var init_resources3 = __esm({
 });
 
 // src/mcp/prompts.ts
-import * as path24 from "path";
-import * as fs22 from "fs";
+import * as path25 from "path";
+import * as fs23 from "fs";
 function loadBaseProtocol2() {
   if (baseProtocolCache !== null) {
     return baseProtocolCache;
   }
-  const basePath = path24.join(getAgentCorePromptsDir(), "_base.md");
-  if (fs22.existsSync(basePath)) {
-    const content = fs22.readFileSync(basePath, "utf-8");
+  const basePath = path25.join(getAgentCorePromptsDir(), "_base.md");
+  if (fs23.existsSync(basePath)) {
+    const content = fs23.readFileSync(basePath, "utf-8");
     baseProtocolCache = content.replace(/^---[\s\S]*?---\n*/, "");
     return baseProtocolCache;
   }
@@ -4335,15 +4461,15 @@ function renderPromptWithContext(content, args) {
     resolvedWorkspaceRoot = activeProject.sourcePath || activeProject.path || activeProject.dataPath;
     resolvedWorkspaceName = activeProject.name;
     if (activeProject.source === "global") {
-      const workspacesDir = path24.dirname(activeProject.dataPath);
-      resolvedRrceHome = path24.dirname(workspacesDir);
+      const workspacesDir = path25.dirname(activeProject.dataPath);
+      resolvedRrceHome = path25.dirname(workspacesDir);
     }
   } else {
     try {
       const workspaceRoot = detectWorkspaceRoot();
-      const workspaceName = path24.basename(workspaceRoot);
-      const globalWorkspacePath = path24.join(DEFAULT_RRCE_HOME, "workspaces", workspaceName);
-      if (fs22.existsSync(globalWorkspacePath)) {
+      const workspaceName = path25.basename(workspaceRoot);
+      const globalWorkspacePath = path25.join(DEFAULT_RRCE_HOME, "workspaces", workspaceName);
+      if (fs23.existsSync(globalWorkspacePath)) {
         resolvedRrceData = globalWorkspacePath;
         resolvedWorkspaceRoot = workspaceRoot;
         resolvedWorkspaceName = workspaceName;
@@ -4555,7 +4681,8 @@ function registerToolHandlers(server) {
           type: "object",
           properties: {
             project: { type: "string", description: "Name of the project to index" },
-            force: { type: "boolean", description: "Force re-indexing of all files" }
+            force: { type: "boolean", description: "Force re-indexing of all files" },
+            clean: { type: "boolean", description: "Wipe existing index and rebuild from scratch" }
           },
           required: ["project"]
         }
@@ -4790,7 +4917,7 @@ function registerToolHandlers(server) {
         }
         case "index_knowledge": {
           const params = args;
-          const result = await indexKnowledge(params.project, params.force);
+          const result = await indexKnowledge(params.project, params.force, params.clean);
           return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
         }
         case "list_projects": {
@@ -5292,105 +5419,6 @@ var init_Header = __esm({
   }
 });
 
-// src/lib/drift-service.ts
-import * as fs23 from "fs";
-import * as path25 from "path";
-import * as crypto2 from "crypto";
-var DriftService;
-var init_drift_service = __esm({
-  "src/lib/drift-service.ts"() {
-    "use strict";
-    DriftService = class {
-      static CHECKSUM_FILENAME = ".rrce-checksums.json";
-      static calculateHash(filePath) {
-        const content = fs23.readFileSync(filePath);
-        return crypto2.createHash("md5").update(content).digest("hex");
-      }
-      static getManifestPath(projectPath) {
-        return path25.join(projectPath, this.CHECKSUM_FILENAME);
-      }
-      static loadManifest(projectPath) {
-        const manifestPath = this.getManifestPath(projectPath);
-        if (!fs23.existsSync(manifestPath)) {
-          return {};
-        }
-        try {
-          return JSON.parse(fs23.readFileSync(manifestPath, "utf8"));
-        } catch (e) {
-          return {};
-        }
-      }
-      static saveManifest(projectPath, manifest) {
-        const manifestPath = this.getManifestPath(projectPath);
-        fs23.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
-      }
-      /**
-       * Generates a manifest for the current state of files in the project
-       */
-      static generateManifest(projectPath, files) {
-        const manifest = {};
-        for (const file of files) {
-          const fullPath = path25.join(projectPath, file);
-          if (fs23.existsSync(fullPath)) {
-            const stats = fs23.statSync(fullPath);
-            manifest[file] = {
-              hash: this.calculateHash(fullPath),
-              mtime: stats.mtimeMs
-            };
-          }
-        }
-        return manifest;
-      }
-      /**
-       * Compares current files against the manifest to detect modifications
-       */
-      static detectModifiedFiles(projectPath) {
-        const manifest = this.loadManifest(projectPath);
-        const modifiedFiles = [];
-        for (const [relPath, entry] of Object.entries(manifest)) {
-          const fullPath = path25.join(projectPath, relPath);
-          if (!fs23.existsSync(fullPath)) {
-            continue;
-          }
-          const stats = fs23.statSync(fullPath);
-          if (stats.mtimeMs === entry.mtime) {
-            continue;
-          }
-          const currentHash = this.calculateHash(fullPath);
-          if (currentHash !== entry.hash) {
-            modifiedFiles.push(relPath);
-          }
-        }
-        return modifiedFiles;
-      }
-      /**
-       * Full drift check: version + modifications
-       */
-      static checkDrift(projectPath, currentVersion, runningVersion) {
-        const modifiedFiles = this.detectModifiedFiles(projectPath);
-        let type = "none";
-        let hasDrift = false;
-        if (currentVersion !== runningVersion) {
-          hasDrift = true;
-          type = "version";
-        } else if (modifiedFiles.length > 0) {
-          hasDrift = true;
-          type = "modified";
-        }
-        return {
-          hasDrift,
-          type,
-          modifiedFiles,
-          version: {
-            current: currentVersion || "0.0.0",
-            running: runningVersion
-          }
-        };
-      }
-    };
-  }
-});
-
 // src/mcp/ui/ConfigContext.tsx
 var ConfigContext_exports = {};
 __export(ConfigContext_exports, {

package/package.json

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