rrce-workflow 0.2.45 → 0.2.47

package/dist/index.js

@@ -705,6 +705,38 @@ var init_autocomplete_prompt = __esm({
   }
 });
 
+// src/lib/preferences.ts
+import * as fs7 from "fs";
+import * as path7 from "path";
+function getPreferencesPath() {
+  const home = process.env.HOME || "~";
+  return path7.join(home, ".rrce-workflow", "preferences.json");
+}
+function loadUserPreferences() {
+  const prefPath = getPreferencesPath();
+  if (!fs7.existsSync(prefPath)) {
+    return {};
+  }
+  try {
+    return JSON.parse(fs7.readFileSync(prefPath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveUserPreferences(prefs) {
+  const prefPath = getPreferencesPath();
+  ensureDir(path7.dirname(prefPath));
+  const current = loadUserPreferences();
+  const refined = { ...current, ...prefs };
+  fs7.writeFileSync(prefPath, JSON.stringify(refined, null, 2));
+}
+var init_preferences = __esm({
+  "src/lib/preferences.ts"() {
+    "use strict";
+    init_paths();
+  }
+});
+
 // src/lib/tui-utils.ts
 var tui_utils_exports = {};
 __export(tui_utils_exports, {
@@ -712,9 +744,10 @@ __export(tui_utils_exports, {
 });
 import { select, note, isCancel } from "@clack/prompts";
 import pc2 from "picocolors";
-import * as path7 from "path";
+import * as path8 from "path";
 async function resolveGlobalPath() {
-  const defaultPath = getDefaultRRCEHome();
+  const prefs = loadUserPreferences();
+  const defaultPath = prefs.defaultGlobalPath || getDefaultRRCEHome();
   const isDefaultWritable = checkWriteAccess(defaultPath);
   const options = [
     {
@@ -750,7 +783,7 @@ Please choose a custom path instead.`,
     }
     return defaultPath;
   }
-  const suggestedPath = path7.join(process.env.HOME || "~", ".local", "share", "rrce-workflow");
+  const suggestedPath = path8.join(process.env.HOME || "~", ".local", "share", "rrce-workflow");
   const customPath = await directoryPrompt({
     message: "Enter custom global path (Tab to autocomplete):",
     defaultValue: suggestedPath,
@@ -769,8 +802,9 @@ Please choose a custom path instead.`,
   }
   let expandedPath = customPath;
   if (!expandedPath.endsWith(".rrce-workflow")) {
-    expandedPath = path7.join(expandedPath, ".rrce-workflow");
+    expandedPath = path8.join(expandedPath, ".rrce-workflow");
   }
+  saveUserPreferences({ defaultGlobalPath: expandedPath });
   return expandedPath;
 }
 var init_tui_utils = __esm({
@@ -778,6 +812,7 @@ var init_tui_utils = __esm({
     "use strict";
     init_paths();
     init_autocomplete_prompt();
+    init_preferences();
   }
 });
 
@@ -821,20 +856,20 @@ __export(config_exports, {
   saveMCPConfig: () => saveMCPConfig,
   setProjectConfig: () => setProjectConfig
 });
-import * as fs7 from "fs";
-import * as path8 from "path";
+import * as fs8 from "fs";
+import * as path9 from "path";
 function getMCPConfigPath() {
   const workspaceRoot = detectWorkspaceRoot();
   const rrceHome = getEffectiveRRCEHome(workspaceRoot);
-  return path8.join(rrceHome, "mcp.yaml");
+  return path9.join(rrceHome, "mcp.yaml");
 }
 function ensureMCPGlobalPath() {
   const workspaceRoot = detectWorkspaceRoot();
   const rrceHome = getEffectiveRRCEHome(workspaceRoot);
   if (rrceHome.startsWith(".") || rrceHome.includes(".rrce-workflow/")) {
-    const configPath = path8.join(workspaceRoot, ".rrce-workflow", "config.yaml");
-    if (fs7.existsSync(configPath)) {
-      const content = fs7.readFileSync(configPath, "utf-8");
+    const configPath = path9.join(workspaceRoot, ".rrce-workflow", "config.yaml");
+    if (fs8.existsSync(configPath)) {
+      const content = fs8.readFileSync(configPath, "utf-8");
       const modeMatch = content.match(/mode:\s*(global|workspace)/);
       if (modeMatch?.[1] === "workspace") {
         return {
@@ -852,11 +887,11 @@ function ensureMCPGlobalPath() {
 }
 function loadMCPConfig() {
   const configPath = getMCPConfigPath();
-  if (!fs7.existsSync(configPath)) {
+  if (!fs8.existsSync(configPath)) {
     return { ...DEFAULT_MCP_CONFIG };
   }
   try {
-    const content = fs7.readFileSync(configPath, "utf-8");
+    const content = fs8.readFileSync(configPath, "utf-8");
     return parseMCPConfig(content);
   } catch {
     return { ...DEFAULT_MCP_CONFIG };
@@ -864,12 +899,12 @@ function loadMCPConfig() {
 }
 function saveMCPConfig(config) {
   const configPath = getMCPConfigPath();
-  const dir = path8.dirname(configPath);
-  if (!fs7.existsSync(dir)) {
-    fs7.mkdirSync(dir, { recursive: true });
+  const dir = path9.dirname(configPath);
+  if (!fs8.existsSync(dir)) {
+    fs8.mkdirSync(dir, { recursive: true });
   }
   const content = serializeMCPConfig(config);
-  fs7.writeFileSync(configPath, content);
+  fs8.writeFileSync(configPath, content);
 }
 function parseMCPConfig(content) {
   const config = { ...DEFAULT_MCP_CONFIG, projects: [] };
@@ -1097,12 +1132,12 @@ var init_config = __esm({
 });
 
 // src/mcp/logger.ts
-import * as fs8 from "fs";
-import * as path9 from "path";
+import * as fs9 from "fs";
+import * as path10 from "path";
 function getLogFilePath() {
   const workspaceRoot = detectWorkspaceRoot();
   const rrceHome = getEffectiveRRCEHome(workspaceRoot);
-  return path9.join(rrceHome, "mcp-server.log");
+  return path10.join(rrceHome, "mcp-server.log");
 }
 var Logger, logger;
 var init_logger = __esm({
@@ -1133,11 +1168,11 @@ ${JSON.stringify(data, null, 2)}`;
         }
         logMessage += "\n";
         try {
-          const dir = path9.dirname(this.logPath);
-          if (!fs8.existsSync(dir)) {
-            fs8.mkdirSync(dir, { recursive: true });
+          const dir = path10.dirname(this.logPath);
+          if (!fs9.existsSync(dir)) {
+            fs9.mkdirSync(dir, { recursive: true });
           }
-          fs8.appendFileSync(this.logPath, logMessage);
+          fs9.appendFileSync(this.logPath, logMessage);
         } catch (e) {
           console.error(`[Logger Failure] Could not write to ${this.logPath}`, e);
           console.error(logMessage);
@@ -1161,9 +1196,8 @@ ${JSON.stringify(data, null, 2)}`;
 });
 
 // src/mcp/services/rag.ts
-import { pipeline } from "@xenova/transformers";
-import * as fs9 from "fs";
-import * as path10 from "path";
+import * as fs10 from "fs";
+import * as path11 from "path";
 var INDEX_VERSION, DEFAULT_MODEL, RAGService;
 var init_rag = __esm({
   "src/mcp/services/rag.ts"() {
@@ -1188,6 +1222,7 @@ var init_rag = __esm({
         if (!this.pipe) {
           logger.info(`RAG: Initializing model ${this.modelName}...`);
           try {
+            const { pipeline } = await import("@xenova/transformers");
             this.pipe = await pipeline("feature-extraction", this.modelName);
             logger.info(`RAG: Model ${this.modelName} initialized successfully.`);
           } catch (error) {
@@ -1203,9 +1238,9 @@ var init_rag = __esm({
        */
       loadIndex() {
         if (this.index) return;
-        if (fs9.existsSync(this.indexPath)) {
+        if (fs10.existsSync(this.indexPath)) {
           try {
-            const data = fs9.readFileSync(this.indexPath, "utf-8");
+            const data = fs10.readFileSync(this.indexPath, "utf-8");
             this.index = JSON.parse(data);
             logger.info(`RAG: Loaded index from ${this.indexPath} with ${this.index?.chunks.length} chunks.`);
           } catch (error) {
@@ -1231,11 +1266,11 @@ var init_rag = __esm({
       saveIndex() {
         if (!this.index) return;
         try {
-          const dir = path10.dirname(this.indexPath);
-          if (!fs9.existsSync(dir)) {
-            fs9.mkdirSync(dir, { recursive: true });
+          const dir = path11.dirname(this.indexPath);
+          if (!fs10.existsSync(dir)) {
+            fs10.mkdirSync(dir, { recursive: true });
           }
-          fs9.writeFileSync(this.indexPath, JSON.stringify(this.index, null, 2));
+          fs10.writeFileSync(this.indexPath, JSON.stringify(this.index, null, 2));
           logger.info(`RAG: Saved index to ${this.indexPath} with ${this.index.chunks.length} chunks.`);
         } catch (error) {
           logger.error(`RAG: Failed to save index to ${this.indexPath}`, error);
@@ -1351,8 +1386,8 @@ var init_rag = __esm({
 });
 
 // src/mcp/resources.ts
-import * as fs10 from "fs";
-import * as path11 from "path";
+import * as fs11 from "fs";
+import * as path12 from "path";
 function getExposedProjects() {
   const config = loadMCPConfig();
   const allProjects = scanForProjects();
@@ -1360,12 +1395,12 @@ function getExposedProjects() {
   const activeProject = detectActiveProject(globalProjects);
   let linkedProjects = [];
   if (activeProject) {
-    const localConfigPath = path11.join(activeProject.dataPath, "config.yaml");
+    const localConfigPath = path12.join(activeProject.dataPath, "config.yaml");
     let cfgContent = null;
-    if (fs10.existsSync(path11.join(activeProject.dataPath, ".rrce-workflow", "config.yaml"))) {
-      cfgContent = fs10.readFileSync(path11.join(activeProject.dataPath, ".rrce-workflow", "config.yaml"), "utf-8");
-    } else if (fs10.existsSync(path11.join(activeProject.dataPath, ".rrce-workflow.yaml"))) {
-      cfgContent = fs10.readFileSync(path11.join(activeProject.dataPath, ".rrce-workflow.yaml"), "utf-8");
+    if (fs11.existsSync(path12.join(activeProject.dataPath, ".rrce-workflow", "config.yaml"))) {
+      cfgContent = fs11.readFileSync(path12.join(activeProject.dataPath, ".rrce-workflow", "config.yaml"), "utf-8");
+    } else if (fs11.existsSync(path12.join(activeProject.dataPath, ".rrce-workflow.yaml"))) {
+      cfgContent = fs11.readFileSync(path12.join(activeProject.dataPath, ".rrce-workflow.yaml"), "utf-8");
     }
     if (cfgContent) {
       if (cfgContent.includes("linked_projects:")) {
@@ -1425,11 +1460,11 @@ function getProjectContext(projectName) {
   if (!project.knowledgePath) {
     return null;
   }
-  const contextPath = path11.join(project.knowledgePath, "project-context.md");
-  if (!fs10.existsSync(contextPath)) {
+  const contextPath = path12.join(project.knowledgePath, "project-context.md");
+  if (!fs11.existsSync(contextPath)) {
     return null;
   }
-  return fs10.readFileSync(contextPath, "utf-8");
+  return fs11.readFileSync(contextPath, "utf-8");
 }
 function getProjectTasks(projectName) {
   const config = loadMCPConfig();
@@ -1442,18 +1477,18 @@ function getProjectTasks(projectName) {
   if (!permissions.tasks) {
     return [];
   }
-  if (!project.tasksPath || !fs10.existsSync(project.tasksPath)) {
+  if (!project.tasksPath || !fs11.existsSync(project.tasksPath)) {
     return [];
   }
   const tasks = [];
   try {
-    const taskDirs = fs10.readdirSync(project.tasksPath, { withFileTypes: true });
+    const taskDirs = fs11.readdirSync(project.tasksPath, { withFileTypes: true });
     for (const dir of taskDirs) {
       if (!dir.isDirectory()) continue;
-      const metaPath = path11.join(project.tasksPath, dir.name, "meta.json");
-      if (fs10.existsSync(metaPath)) {
+      const metaPath = path12.join(project.tasksPath, dir.name, "meta.json");
+      if (fs11.existsSync(metaPath)) {
         try {
-          const meta = JSON.parse(fs10.readFileSync(metaPath, "utf-8"));
+          const meta = JSON.parse(fs11.readFileSync(metaPath, "utf-8"));
           tasks.push(meta);
         } catch {
         }
@@ -1477,13 +1512,13 @@ async function searchKnowledge(query) {
     const useRAG = projConfig?.semanticSearch?.enabled;
     if (useRAG) {
       try {
-        const indexPath = path11.join(project.knowledgePath, "embeddings.json");
+        const indexPath = path12.join(project.knowledgePath, "embeddings.json");
         const rag = new RAGService(indexPath, projConfig?.semanticSearch?.model);
         const ragResults = await rag.search(query, 5);
         for (const r of ragResults) {
           results.push({
             project: project.name,
-            file: path11.relative(project.knowledgePath, r.filePath),
+            file: path12.relative(project.knowledgePath, r.filePath),
             matches: [r.content],
             // The chunk content is the match
             score: r.score
@@ -1494,11 +1529,11 @@ async function searchKnowledge(query) {
       continue;
     }
     try {
-      const files = fs10.readdirSync(project.knowledgePath);
+      const files = fs11.readdirSync(project.knowledgePath);
       for (const file of files) {
         if (!file.endsWith(".md")) continue;
-        const filePath = path11.join(project.knowledgePath, file);
-        const content = fs10.readFileSync(filePath, "utf-8");
+        const filePath = path12.join(project.knowledgePath, file);
+        const content = fs11.readFileSync(filePath, "utf-8");
         const lines = content.split("\n");
         const matches = [];
         for (const line of lines) {
@@ -1533,18 +1568,18 @@ async function indexKnowledge(projectName, force = false) {
   if (!projConfig?.semanticSearch?.enabled) {
     return { success: false, message: "Semantic Search is not enabled for this project", filesIndexed: 0 };
   }
-  if (!project.knowledgePath || !fs10.existsSync(project.knowledgePath)) {
+  if (!project.knowledgePath || !fs11.existsSync(project.knowledgePath)) {
     return { success: false, message: "No knowledge directory found", filesIndexed: 0 };
   }
   try {
-    const indexPath = path11.join(project.knowledgePath, "embeddings.json");
+    const indexPath = path12.join(project.knowledgePath, "embeddings.json");
     const rag = new RAGService(indexPath, projConfig.semanticSearch.model);
-    const files = fs10.readdirSync(project.knowledgePath).filter((f) => f.endsWith(".md"));
+    const files = fs11.readdirSync(project.knowledgePath).filter((f) => f.endsWith(".md"));
     let count = 0;
     for (const file of files) {
-      const filePath = path11.join(project.knowledgePath, file);
-      const content = fs10.readFileSync(filePath, "utf-8");
-      await rag.indexFile(path11.join(project.knowledgePath, file), content);
+      const filePath = path12.join(project.knowledgePath, file);
+      const content = fs11.readFileSync(filePath, "utf-8");
+      await rag.indexFile(path12.join(project.knowledgePath, file), content);
       count++;
     }
     return { success: true, message: `Successfully indexed ${count} files`, filesIndexed: count };
@@ -2046,8 +2081,8 @@ var init_server = __esm({
 });
 
 // src/mcp/install.ts
-import * as fs11 from "fs";
-import * as path12 from "path";
+import * as fs12 from "fs";
+import * as path13 from "path";
 import * as os from "os";
 function checkInstallStatus(workspacePath) {
   return {
@@ -2058,37 +2093,37 @@ function checkInstallStatus(workspacePath) {
   };
 }
 function checkAntigravityConfig() {
-  if (!fs11.existsSync(ANTIGRAVITY_CONFIG)) return false;
+  if (!fs12.existsSync(ANTIGRAVITY_CONFIG)) return false;
   try {
-    const content = JSON.parse(fs11.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
+    const content = JSON.parse(fs12.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
     return !!content.mcpServers?.["rrce"];
   } catch {
     return false;
   }
 }
 function checkClaudeConfig() {
-  if (!fs11.existsSync(CLAUDE_CONFIG)) return false;
+  if (!fs12.existsSync(CLAUDE_CONFIG)) return false;
   try {
-    const content = JSON.parse(fs11.readFileSync(CLAUDE_CONFIG, "utf-8"));
+    const content = JSON.parse(fs12.readFileSync(CLAUDE_CONFIG, "utf-8"));
     return !!content.mcpServers?.["rrce"];
   } catch {
     return false;
   }
 }
 function checkVSCodeGlobalConfig() {
-  if (!fs11.existsSync(VSCODE_GLOBAL_CONFIG)) return false;
+  if (!fs12.existsSync(VSCODE_GLOBAL_CONFIG)) return false;
   try {
-    const content = JSON.parse(fs11.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
+    const content = JSON.parse(fs12.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
     return !!content["mcp.servers"]?.["rrce"];
   } catch {
     return false;
   }
 }
 function checkVSCodeWorkspaceConfig(workspacePath) {
-  const configPath = path12.join(workspacePath, ".vscode", "mcp.json");
-  if (!fs11.existsSync(configPath)) return false;
+  const configPath = path13.join(workspacePath, ".vscode", "mcp.json");
+  if (!fs12.existsSync(configPath)) return false;
   try {
-    const content = JSON.parse(fs11.readFileSync(configPath, "utf-8"));
+    const content = JSON.parse(fs12.readFileSync(configPath, "utf-8"));
     return !!content.servers?.["rrce"];
   } catch {
     return false;
@@ -2113,14 +2148,14 @@ function installToConfig(target, workspacePath) {
   }
 }
 function installToAntigravity() {
-  const dir = path12.dirname(ANTIGRAVITY_CONFIG);
-  if (!fs11.existsSync(dir)) {
-    fs11.mkdirSync(dir, { recursive: true });
+  const dir = path13.dirname(ANTIGRAVITY_CONFIG);
+  if (!fs12.existsSync(dir)) {
+    fs12.mkdirSync(dir, { recursive: true });
   }
   let config = { mcpServers: {} };
-  if (fs11.existsSync(ANTIGRAVITY_CONFIG)) {
+  if (fs12.existsSync(ANTIGRAVITY_CONFIG)) {
     try {
-      config = JSON.parse(fs11.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
+      config = JSON.parse(fs12.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
     } catch {
     }
   }
@@ -2130,21 +2165,21 @@ function installToAntigravity() {
     args: ["-y", "rrce-workflow", "mcp", "start"]
   };
   try {
-    fs11.writeFileSync(ANTIGRAVITY_CONFIG, JSON.stringify(config, null, 2));
+    fs12.writeFileSync(ANTIGRAVITY_CONFIG, JSON.stringify(config, null, 2));
     return true;
   } catch {
     return false;
   }
 }
 function installToClaude() {
-  const dir = path12.dirname(CLAUDE_CONFIG);
-  if (!fs11.existsSync(dir)) {
-    fs11.mkdirSync(dir, { recursive: true });
+  const dir = path13.dirname(CLAUDE_CONFIG);
+  if (!fs12.existsSync(dir)) {
+    fs12.mkdirSync(dir, { recursive: true });
   }
   let config = { mcpServers: {} };
-  if (fs11.existsSync(CLAUDE_CONFIG)) {
+  if (fs12.existsSync(CLAUDE_CONFIG)) {
     try {
-      config = JSON.parse(fs11.readFileSync(CLAUDE_CONFIG, "utf-8"));
+      config = JSON.parse(fs12.readFileSync(CLAUDE_CONFIG, "utf-8"));
     } catch {
     }
   }
@@ -2154,21 +2189,21 @@ function installToClaude() {
     args: ["-y", "rrce-workflow", "mcp", "start"]
   };
   try {
-    fs11.writeFileSync(CLAUDE_CONFIG, JSON.stringify(config, null, 2));
+    fs12.writeFileSync(CLAUDE_CONFIG, JSON.stringify(config, null, 2));
     return true;
   } catch {
     return false;
   }
 }
 function installToVSCodeGlobal() {
-  const dir = path12.dirname(VSCODE_GLOBAL_CONFIG);
-  if (!fs11.existsSync(dir)) {
-    fs11.mkdirSync(dir, { recursive: true });
+  const dir = path13.dirname(VSCODE_GLOBAL_CONFIG);
+  if (!fs12.existsSync(dir)) {
+    fs12.mkdirSync(dir, { recursive: true });
   }
   let settings = {};
-  if (fs11.existsSync(VSCODE_GLOBAL_CONFIG)) {
+  if (fs12.existsSync(VSCODE_GLOBAL_CONFIG)) {
     try {
-      settings = JSON.parse(fs11.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
+      settings = JSON.parse(fs12.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
     } catch {
     }
   }
@@ -2178,22 +2213,22 @@ function installToVSCodeGlobal() {
     args: ["-y", "rrce-workflow", "mcp", "start"]
   };
   try {
-    fs11.writeFileSync(VSCODE_GLOBAL_CONFIG, JSON.stringify(settings, null, 2));
+    fs12.writeFileSync(VSCODE_GLOBAL_CONFIG, JSON.stringify(settings, null, 2));
     return true;
   } catch {
     return false;
   }
 }
 function installToVSCodeWorkspace(workspacePath) {
-  const vscodeDir = path12.join(workspacePath, ".vscode");
-  const configPath = path12.join(vscodeDir, "mcp.json");
-  if (!fs11.existsSync(vscodeDir)) {
-    fs11.mkdirSync(vscodeDir, { recursive: true });
+  const vscodeDir = path13.join(workspacePath, ".vscode");
+  const configPath = path13.join(vscodeDir, "mcp.json");
+  if (!fs12.existsSync(vscodeDir)) {
+    fs12.mkdirSync(vscodeDir, { recursive: true });
   }
   let config = { servers: {} };
-  if (fs11.existsSync(configPath)) {
+  if (fs12.existsSync(configPath)) {
     try {
-      config = JSON.parse(fs11.readFileSync(configPath, "utf-8"));
+      config = JSON.parse(fs12.readFileSync(configPath, "utf-8"));
     } catch {
     }
   }
@@ -2203,7 +2238,7 @@ function installToVSCodeWorkspace(workspacePath) {
     args: ["-y", "rrce-workflow", "mcp", "start"]
   };
   try {
-    fs11.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    fs12.writeFileSync(configPath, JSON.stringify(config, null, 2));
     return true;
   } catch {
     return false;
@@ -2227,9 +2262,9 @@ var ANTIGRAVITY_CONFIG, CLAUDE_CONFIG, VSCODE_GLOBAL_CONFIG;
 var init_install = __esm({
   "src/mcp/install.ts"() {
     "use strict";
-    ANTIGRAVITY_CONFIG = path12.join(os.homedir(), ".gemini/antigravity/mcp_config.json");
-    CLAUDE_CONFIG = path12.join(os.homedir(), ".config/claude/claude_desktop_config.json");
-    VSCODE_GLOBAL_CONFIG = path12.join(os.homedir(), ".config/Code/User/settings.json");
+    ANTIGRAVITY_CONFIG = path13.join(os.homedir(), ".gemini/antigravity/mcp_config.json");
+    CLAUDE_CONFIG = path13.join(os.homedir(), ".config/claude/claude_desktop_config.json");
+    VSCODE_GLOBAL_CONFIG = path13.join(os.homedir(), ".config/Code/User/settings.json");
   }
 });
 
@@ -2314,8 +2349,8 @@ Hidden projects: ${projects.length - exposedCount}`,
 }
 async function handleConfigureGlobalPath() {
   const { resolveGlobalPath: resolveGlobalPath2 } = await Promise.resolve().then(() => (init_tui_utils(), tui_utils_exports));
-  const fs18 = await import("fs");
-  const path17 = await import("path");
+  const fs19 = await import("fs");
+  const path18 = await import("path");
   note2(
     `MCP Hub requires a ${pc3.bold("global storage path")} to store its configuration
 and coordinate across projects.
@@ -2329,8 +2364,8 @@ locally in each project. MCP needs a central location.`,
     return false;
   }
   try {
-    if (!fs18.existsSync(resolvedPath)) {
-      fs18.mkdirSync(resolvedPath, { recursive: true });
+    if (!fs19.existsSync(resolvedPath)) {
+      fs19.mkdirSync(resolvedPath, { recursive: true });
     }
     const config = loadMCPConfig();
     saveMCPConfig(config);
@@ -2338,7 +2373,7 @@ locally in each project. MCP needs a central location.`,
       `${pc3.green("\u2713")} Global path configured: ${pc3.cyan(resolvedPath)}
 
 MCP config will be stored at:
-${path17.join(resolvedPath, "mcp.yaml")}`,
+${path18.join(resolvedPath, "mcp.yaml")}`,
       "Configuration Saved"
     );
     return true;
@@ -2815,7 +2850,7 @@ __export(App_exports, {
 });
 import { useState as useState4, useEffect as useEffect4 } from "react";
 import { Box as Box10, useInput as useInput3, useApp } from "ink";
-import fs12 from "fs";
+import fs13 from "fs";
 import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
 var TABS, App;
 var init_App = __esm({
@@ -2884,18 +2919,18 @@ var init_App = __esm({
       useEffect4(() => {
         const logPath = getLogFilePath();
         let lastSize = 0;
-        if (fs12.existsSync(logPath)) {
-          const stats = fs12.statSync(logPath);
+        if (fs13.existsSync(logPath)) {
+          const stats = fs13.statSync(logPath);
           lastSize = stats.size;
         }
         const interval = setInterval(() => {
-          if (fs12.existsSync(logPath)) {
-            const stats = fs12.statSync(logPath);
+          if (fs13.existsSync(logPath)) {
+            const stats = fs13.statSync(logPath);
             if (stats.size > lastSize) {
               const buffer = Buffer.alloc(stats.size - lastSize);
-              const fd = fs12.openSync(logPath, "r");
-              fs12.readSync(fd, buffer, 0, buffer.length, lastSize);
-              fs12.closeSync(fd);
+              const fd = fs13.openSync(logPath, "r");
+              fs13.readSync(fd, buffer, 0, buffer.length, lastSize);
+              fs13.closeSync(fd);
               const newContent = buffer.toString("utf-8");
               const newLines = newContent.split("\n").filter((l) => l.trim());
               setLogs((prev) => {
@@ -3229,8 +3264,8 @@ var init_mcp = __esm({
 // src/commands/wizard/setup-flow.ts
 import { group, select as select2, multiselect as multiselect3, confirm as confirm4, spinner as spinner3, note as note7, outro as outro2, cancel as cancel2, isCancel as isCancel6 } from "@clack/prompts";
 import pc8 from "picocolors";
-import * as fs13 from "fs";
-import * as path13 from "path";
+import * as fs14 from "fs";
+import * as path14 from "path";
 async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
   const s = spinner3();
   const config = await group(
@@ -3279,7 +3314,21 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
       exposeToMCP: () => confirm4({
         message: "Expose this project to MCP (AI Agent) server?",
         initialValue: true
-      })
+      }),
+      enableRAG: () => confirm4({
+        message: "Enable Semantic Search (Local Mini RAG)?",
+        initialValue: false
+        // Default false because it's heavy
+      }),
+      enableRAGConfirm: ({ results }) => {
+        if (results.enableRAG) {
+          return confirm4({
+            message: `${pc8.yellow("Warning:")} This will download a ~100MB model (Xenova/all-MiniLM-L6-v2) on first use. Proceed?`,
+            initialValue: true
+          });
+        }
+        return Promise.resolve(true);
+      }
     },
     {
       onCancel: () => {
@@ -3308,7 +3357,8 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
       tools: config.tools,
       linkedProjects: config.linkedProjects,
       addToGitignore: config.addToGitignore,
-      exposeToMCP: config.exposeToMCP
+      exposeToMCP: config.exposeToMCP,
+      enableRAG: config.enableRAG && config.enableRAGConfirm
     }, workspacePath, workspaceName, existingProjects);
     s.stop("Configuration generated");
     const dataPaths = getDataPaths(
@@ -3370,27 +3420,29 @@ async function generateConfiguration(config, workspacePath, workspaceName, allPr
   const dataPaths = getDataPaths(config.storageMode, workspaceName, workspacePath, config.globalPath);
   for (const dataPath of dataPaths) {
     ensureDir(dataPath);
-    ensureDir(path13.join(dataPath, "knowledge"));
-    ensureDir(path13.join(dataPath, "refs"));
-    ensureDir(path13.join(dataPath, "tasks"));
-    ensureDir(path13.join(dataPath, "templates"));
+    ensureDir(path14.join(dataPath, "knowledge"));
+    ensureDir(path14.join(dataPath, "refs"));
+    ensureDir(path14.join(dataPath, "tasks"));
+    ensureDir(path14.join(dataPath, "templates"));
   }
   const agentCoreDir = getAgentCoreDir();
   syncMetadataToAll(agentCoreDir, dataPaths);
-  copyDirToAllStoragePaths(path13.join(agentCoreDir, "templates"), "templates", dataPaths);
+  copyDirToAllStoragePaths(path14.join(agentCoreDir, "templates"), "templates", dataPaths);
   const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
-  if (config.tools.includes("copilot")) {
-    const copilotPath = getAgentPromptPath(workspacePath, "copilot");
-    ensureDir(copilotPath);
-    copyPromptsToDir(prompts, copilotPath, ".agent.md");
-  }
-  if (config.tools.includes("antigravity")) {
-    const antigravityPath = getAgentPromptPath(workspacePath, "antigravity");
-    ensureDir(antigravityPath);
-    copyPromptsToDir(prompts, antigravityPath, ".md");
-  }
-  const workspaceConfigPath = path13.join(workspacePath, ".rrce-workflow", "config.yaml");
-  ensureDir(path13.dirname(workspaceConfigPath));
+  if (config.storageMode === "workspace") {
+    if (config.tools.includes("copilot")) {
+      const copilotPath = getAgentPromptPath(workspacePath, "copilot");
+      ensureDir(copilotPath);
+      copyPromptsToDir(prompts, copilotPath, ".agent.md");
+    }
+    if (config.tools.includes("antigravity")) {
+      const antigravityPath = getAgentPromptPath(workspacePath, "antigravity");
+      ensureDir(antigravityPath);
+      copyPromptsToDir(prompts, antigravityPath, ".md");
+    }
+  }
+  const workspaceConfigPath = path14.join(workspacePath, ".rrce-workflow", "config.yaml");
+  ensureDir(path14.dirname(workspaceConfigPath));
   let configContent = `# RRCE-Workflow Configuration
 version: 1
 
@@ -3418,7 +3470,7 @@ linked_projects:
 `;
     });
   }
-  fs13.writeFileSync(workspaceConfigPath, configContent);
+  fs14.writeFileSync(workspaceConfigPath, configContent);
   if (config.addToGitignore) {
     updateGitignore(workspacePath, config.storageMode, config.tools);
   }
@@ -3435,10 +3487,30 @@ linked_projects:
       const mcpConfig = loadMCPConfig3();
       const currentProjectName = workspaceName;
       if (config.storageMode === "workspace") {
-        setProjectConfig2(mcpConfig, currentProjectName, true);
+        setProjectConfig2(
+          mcpConfig,
+          currentProjectName,
+          true,
+          void 0,
+          // permissions
+          void 0,
+          // path
+          config.enableRAG ? { enabled: true } : void 0
+          // semanticSearch
+        );
         saveMCPConfig2(mcpConfig);
       } else {
-        setProjectConfig2(mcpConfig, currentProjectName, true);
+        setProjectConfig2(
+          mcpConfig,
+          currentProjectName,
+          true,
+          void 0,
+          // permissions
+          void 0,
+          // path
+          config.enableRAG ? { enabled: true } : void 0
+          // semanticSearch
+        );
         saveMCPConfig2(mcpConfig);
       }
     } catch (e) {
@@ -3447,8 +3519,8 @@ linked_projects:
   }
 }
 function getDataPaths(mode, workspaceName, workspaceRoot, customGlobalPath) {
-  const globalPath = path13.join(customGlobalPath || getDefaultRRCEHome(), "workspaces", workspaceName);
-  const workspacePath = path13.join(workspaceRoot, ".rrce-workflow");
+  const globalPath = path14.join(customGlobalPath || getDefaultRRCEHome(), "workspaces", workspaceName);
+  const workspacePath = path14.join(workspaceRoot, ".rrce-workflow");
   switch (mode) {
     case "global":
       return [globalPath];
@@ -3459,7 +3531,7 @@ function getDataPaths(mode, workspaceName, workspaceRoot, customGlobalPath) {
   }
 }
 function updateGitignore(workspacePath, storageMode, tools) {
-  const gitignorePath = path13.join(workspacePath, ".gitignore");
+  const gitignorePath = path14.join(workspacePath, ".gitignore");
   const entries = [];
   if (storageMode === "workspace") {
     entries.push(".rrce-workflow/");
@@ -3475,8 +3547,8 @@ function updateGitignore(workspacePath, storageMode, tools) {
   }
   try {
     let content = "";
-    if (fs13.existsSync(gitignorePath)) {
-      content = fs13.readFileSync(gitignorePath, "utf-8");
+    if (fs14.existsSync(gitignorePath)) {
+      content = fs14.readFileSync(gitignorePath, "utf-8");
     }
     const lines = content.split("\n").map((line) => line.trim());
     const newEntries = [];
@@ -3501,7 +3573,7 @@ function updateGitignore(workspacePath, storageMode, tools) {
       newContent += "\n# rrce-workflow generated folders (uncomment to ignore)\n";
     }
     newContent += newEntries.map((e) => `# ${e}`).join("\n") + "\n";
-    fs13.writeFileSync(gitignorePath, newContent);
+    fs14.writeFileSync(gitignorePath, newContent);
     return true;
   } catch {
     return false;
@@ -3522,7 +3594,7 @@ var init_setup_flow = __esm({
 // src/commands/wizard/link-flow.ts
 import { multiselect as multiselect4, spinner as spinner4, note as note8, outro as outro3, cancel as cancel3, isCancel as isCancel7, confirm as confirm5 } from "@clack/prompts";
 import pc9 from "picocolors";
-import * as fs14 from "fs";
+import * as fs15 from "fs";
 async function runLinkProjectsFlow(workspacePath, workspaceName) {
   const projects = scanForProjects({
     excludeWorkspace: workspaceName,
@@ -3560,7 +3632,7 @@ async function runLinkProjectsFlow(workspacePath, workspaceName) {
   const s = spinner4();
   s.start("Linking projects");
   const configFilePath = getConfigPath(workspacePath);
-  let configContent = fs14.readFileSync(configFilePath, "utf-8");
+  let configContent = fs15.readFileSync(configFilePath, "utf-8");
   if (configContent.includes("linked_projects:")) {
     const lines = configContent.split("\n");
     const linkedIndex = lines.findIndex((l) => l.trim() === "linked_projects:");
@@ -3587,7 +3659,7 @@ linked_projects:
 `;
     });
   }
-  fs14.writeFileSync(configFilePath, configContent);
+  fs15.writeFileSync(configFilePath, configContent);
   generateVSCodeWorkspace(workspacePath, workspaceName, selectedProjects, customGlobalPath);
   s.stop("Projects linked");
   const workspaceFile = `${workspaceName}.code-workspace`;
@@ -3629,15 +3701,15 @@ var init_link_flow = __esm({
 // src/commands/wizard/sync-flow.ts
 import { confirm as confirm6, spinner as spinner5, note as note9, outro as outro4, cancel as cancel4, isCancel as isCancel8 } from "@clack/prompts";
 import pc10 from "picocolors";
-import * as fs15 from "fs";
-import * as path14 from "path";
+import * as fs16 from "fs";
+import * as path15 from "path";
 async function runSyncToGlobalFlow(workspacePath, workspaceName) {
   const localPath = getLocalWorkspacePath(workspacePath);
   const customGlobalPath = getEffectiveRRCEHome(workspacePath);
-  const globalPath = path14.join(customGlobalPath, "workspaces", workspaceName);
+  const globalPath = path15.join(customGlobalPath, "workspaces", workspaceName);
   const subdirs = ["knowledge", "prompts", "templates", "tasks", "refs"];
   const existingDirs = subdirs.filter(
-    (dir) => fs15.existsSync(path14.join(localPath, dir))
+    (dir) => fs16.existsSync(path15.join(localPath, dir))
   );
   if (existingDirs.length === 0) {
     outro4(pc10.yellow("No data found in workspace storage to sync."));
@@ -3663,8 +3735,8 @@ Destination: ${pc10.cyan(globalPath)}`,
   try {
     ensureDir(globalPath);
     for (const dir of existingDirs) {
-      const srcDir = path14.join(localPath, dir);
-      const destDir = path14.join(globalPath, dir);
+      const srcDir = path15.join(localPath, dir);
+      const destDir = path15.join(globalPath, dir);
       ensureDir(destDir);
       copyDirRecursive(srcDir, destDir);
     }
@@ -3696,8 +3768,8 @@ var init_sync_flow = __esm({
 // src/commands/wizard/update-flow.ts
 import { confirm as confirm7, spinner as spinner6, note as note10, outro as outro5, cancel as cancel5, isCancel as isCancel9 } from "@clack/prompts";
 import pc11 from "picocolors";
-import * as fs16 from "fs";
-import * as path15 from "path";
+import * as fs17 from "fs";
+import * as path16 from "path";
 async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
   const s = spinner6();
   s.start("Checking for updates");
@@ -3727,10 +3799,10 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
     }
     s.start("Updating from package");
     for (const dataPath of dataPaths) {
-      copyDirToAllStoragePaths(path15.join(agentCoreDir, "templates"), "templates", [dataPath]);
+      copyDirToAllStoragePaths(path16.join(agentCoreDir, "templates"), "templates", [dataPath]);
     }
     const configFilePath = getConfigPath(workspacePath);
-    const configContent = fs16.readFileSync(configFilePath, "utf-8");
+    const configContent = fs17.readFileSync(configFilePath, "utf-8");
     if (configContent.includes("copilot: true")) {
       const copilotPath = getAgentPromptPath(workspacePath, "copilot");
       ensureDir(copilotPath);
@@ -3758,8 +3830,8 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
   }
 }
 function resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspaceRoot, customGlobalPath) {
-  const globalPath = path15.join(customGlobalPath, "workspaces", workspaceName);
-  const workspacePath = path15.join(workspaceRoot, ".rrce-workflow");
+  const globalPath = path16.join(customGlobalPath, "workspaces", workspaceName);
+  const workspacePath = path16.join(workspaceRoot, ".rrce-workflow");
   switch (mode) {
     case "global":
       return [globalPath];
@@ -3785,7 +3857,7 @@ __export(wizard_exports, {
 });
 import { intro as intro2, select as select3, spinner as spinner7, note as note11, outro as outro6, isCancel as isCancel10 } from "@clack/prompts";
 import pc12 from "picocolors";
-import * as fs17 from "fs";
+import * as fs18 from "fs";
 async function runWizard() {
   intro2(pc12.cyan(pc12.inverse(" RRCE-Workflow Setup ")));
   const s = spinner7();
@@ -3805,18 +3877,18 @@ Workspace: ${pc12.bold(workspaceName)}`,
     workspacePath
   });
   const configFilePath = getConfigPath(workspacePath);
-  const isAlreadyConfigured = fs17.existsSync(configFilePath);
+  const isAlreadyConfigured = fs18.existsSync(configFilePath);
   let currentStorageMode = null;
   if (isAlreadyConfigured) {
     try {
-      const configContent = fs17.readFileSync(configFilePath, "utf-8");
+      const configContent = fs18.readFileSync(configFilePath, "utf-8");
       const modeMatch = configContent.match(/mode:\s*(global|workspace)/);
       currentStorageMode = modeMatch?.[1] ?? null;
     } catch {
     }
   }
   const localDataPath = getLocalWorkspacePath(workspacePath);
-  const hasLocalData = fs17.existsSync(localDataPath);
+  const hasLocalData = fs18.existsSync(localDataPath);
   if (isAlreadyConfigured) {
     const menuOptions = [];
     menuOptions.push({
@@ -3891,9 +3963,9 @@ init_wizard();
 init_prompts();
 import { intro as intro3, select as select4, note as note12, cancel as cancel7, isCancel as isCancel11, outro as outro7 } from "@clack/prompts";
 import pc13 from "picocolors";
-import * as path16 from "path";
+import * as path17 from "path";
 async function runSelector() {
-  const workspaceName = path16.basename(process.cwd());
+  const workspaceName = path17.basename(process.cwd());
   intro3(pc13.cyan(pc13.inverse(` RRCE-Workflow | ${workspaceName} `)));
   const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
   if (prompts.length === 0) {

package/package.json

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