rrce-workflow 0.3.1 → 0.3.2

package/dist/index.js

@@ -574,9 +574,97 @@ var init_detection_service = __esm({
   }
 });
 
-// src/lib/autocomplete-prompt.ts
+// src/types/prompt.ts
+import { z } from "zod";
+var PromptArgSchema, AutoIdentitySchema, PromptFrontmatterSchema;
+var init_prompt = __esm({
+  "src/types/prompt.ts"() {
+    "use strict";
+    PromptArgSchema = z.object({
+      name: z.string(),
+      default: z.string().optional(),
+      prompt: z.string().optional()
+    });
+    AutoIdentitySchema = z.object({
+      user: z.string(),
+      model: z.string()
+    });
+    PromptFrontmatterSchema = z.object({
+      name: z.string(),
+      description: z.string(),
+      "argument-hint": z.union([z.string(), z.array(z.string())]).optional(),
+      tools: z.array(z.string()).optional(),
+      mode: z.enum(["primary", "subagent"]).optional(),
+      "required-args": z.array(PromptArgSchema).optional(),
+      "optional-args": z.array(PromptArgSchema).optional(),
+      "auto-identity": AutoIdentitySchema.optional()
+    });
+  }
+});
+
+// src/lib/prompts.ts
 import * as fs4 from "fs";
 import * as path4 from "path";
+import { fileURLToPath } from "url";
+import matter from "gray-matter";
+function parsePromptFile(filePath) {
+  try {
+    const fileContent = fs4.readFileSync(filePath, "utf-8");
+    const { data, content } = matter(fileContent);
+    const parsed = PromptFrontmatterSchema.safeParse(data);
+    if (!parsed.success) {
+      console.error(`Failed to parse frontmatter in ${filePath}:`, parsed.error);
+      return null;
+    }
+    return {
+      frontmatter: parsed.data,
+      content: content.trim(),
+      filePath
+    };
+  } catch (error) {
+    console.error(`Error reading prompt file ${filePath}:`, error);
+    return null;
+  }
+}
+function loadPromptsFromDir(dirPath) {
+  if (!fs4.existsSync(dirPath)) {
+    return [];
+  }
+  const files = fs4.readdirSync(dirPath).filter((f) => f.endsWith(".md"));
+  const prompts = [];
+  for (const file of files) {
+    const prompt = parsePromptFile(path4.join(dirPath, file));
+    if (prompt) {
+      prompts.push(prompt);
+    }
+  }
+  return prompts;
+}
+function getAgentCoreDir() {
+  if (__dirname.includes("/src/") || __dirname.includes("\\src\\")) {
+    if (fs4.existsSync(path4.join(process.cwd(), "agent-core"))) {
+      return path4.join(process.cwd(), "agent-core");
+    }
+    return path4.resolve(__dirname, "../..", "agent-core");
+  }
+  return path4.join(__dirname, "..", "agent-core");
+}
+function getAgentCorePromptsDir() {
+  return path4.join(getAgentCoreDir(), "prompts");
+}
+var __filename, __dirname;
+var init_prompts = __esm({
+  "src/lib/prompts.ts"() {
+    "use strict";
+    init_prompt();
+    __filename = fileURLToPath(import.meta.url);
+    __dirname = path4.dirname(__filename);
+  }
+});
+
+// src/lib/autocomplete-prompt.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
 import * as readline from "readline";
 import pc from "picocolors";
 function directoryPrompt(opts) {
@@ -635,19 +723,19 @@ function completeDirectory(line) {
       prefix = "";
       basePath = expanded;
     } else {
-      dirToScan = path4.dirname(expanded);
-      prefix = path4.basename(expanded).toLowerCase();
+      dirToScan = path5.dirname(expanded);
+      prefix = path5.basename(expanded).toLowerCase();
       basePath = dirToScan === "/" ? "/" : dirToScan + "/";
     }
-    if (!fs4.existsSync(dirToScan)) {
+    if (!fs5.existsSync(dirToScan)) {
       return [[], line];
     }
-    const entries = fs4.readdirSync(dirToScan, { withFileTypes: true }).filter((entry) => {
+    const entries = fs5.readdirSync(dirToScan, { withFileTypes: true }).filter((entry) => {
       if (!entry.isDirectory()) return false;
       if (entry.name.startsWith(".") && !prefix.startsWith(".")) return false;
       return prefix === "" || entry.name.toLowerCase().startsWith(prefix);
     }).map((entry) => {
-      const fullPath = path4.join(dirToScan, entry.name);
+      const fullPath = path5.join(dirToScan, entry.name);
       const displayPath = fullPath.startsWith(process.env.HOME || "") ? fullPath.replace(process.env.HOME || "", "~") : fullPath;
       return displayPath + "/";
     }).sort();
@@ -693,7 +781,7 @@ __export(tui_utils_exports, {
 });
 import { select, note, isCancel } from "@clack/prompts";
 import pc2 from "picocolors";
-import * as path5 from "path";
+import * as path6 from "path";
 async function resolveGlobalPath() {
   const prefs = loadUserPreferences();
   const defaultPath = prefs.defaultGlobalPath || getDefaultRRCEHome2();
@@ -732,7 +820,7 @@ Please choose a custom path instead.`,
     }
     return defaultPath;
   }
-  const suggestedPath = path5.join(process.env.HOME || "~", ".rrce-workflow");
+  const suggestedPath = path6.join(process.env.HOME || "~", ".rrce-workflow");
   const customPath = await directoryPrompt({
     message: "Enter custom global path (Tab to autocomplete):",
     defaultValue: suggestedPath,
@@ -751,7 +839,7 @@ Please choose a custom path instead.`,
   }
   let expandedPath = customPath;
   if (!expandedPath.endsWith(".rrce-workflow")) {
-    expandedPath = path5.join(expandedPath, ".rrce-workflow");
+    expandedPath = path6.join(expandedPath, ".rrce-workflow");
   }
   saveUserPreferences({ defaultGlobalPath: expandedPath, useCustomGlobalPath: true });
   return expandedPath;
@@ -766,8 +854,8 @@ var init_tui_utils = __esm({
 });
 
 // src/mcp/install.ts
-import * as fs5 from "fs";
-import * as path6 from "path";
+import * as fs6 from "fs";
+import * as path7 from "path";
 import * as os from "os";
 function checkInstallStatus(workspacePath) {
   return {
@@ -779,46 +867,46 @@ function checkInstallStatus(workspacePath) {
   };
 }
 function checkAntigravityConfig() {
-  if (!fs5.existsSync(ANTIGRAVITY_CONFIG)) return false;
+  if (!fs6.existsSync(ANTIGRAVITY_CONFIG)) return false;
   try {
-    const content = JSON.parse(fs5.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
+    const content = JSON.parse(fs6.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
     return !!content.mcpServers?.["rrce"];
   } catch {
     return false;
   }
 }
 function checkClaudeConfig() {
-  if (!fs5.existsSync(CLAUDE_CONFIG)) return false;
+  if (!fs6.existsSync(CLAUDE_CONFIG)) return false;
   try {
-    const content = JSON.parse(fs5.readFileSync(CLAUDE_CONFIG, "utf-8"));
+    const content = JSON.parse(fs6.readFileSync(CLAUDE_CONFIG, "utf-8"));
     return !!content.mcpServers?.["rrce"];
   } catch {
     return false;
   }
 }
 function checkVSCodeGlobalConfig() {
-  if (!fs5.existsSync(VSCODE_GLOBAL_CONFIG)) return false;
+  if (!fs6.existsSync(VSCODE_GLOBAL_CONFIG)) return false;
   try {
-    const content = JSON.parse(fs5.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
+    const content = JSON.parse(fs6.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
     return !!content["mcp.servers"]?.["rrce"];
   } catch {
     return false;
   }
 }
 function checkVSCodeWorkspaceConfig(workspacePath) {
-  const configPath = path6.join(workspacePath, ".vscode", "mcp.json");
-  if (!fs5.existsSync(configPath)) return false;
+  const configPath = path7.join(workspacePath, ".vscode", "mcp.json");
+  if (!fs6.existsSync(configPath)) return false;
   try {
-    const content = JSON.parse(fs5.readFileSync(configPath, "utf-8"));
+    const content = JSON.parse(fs6.readFileSync(configPath, "utf-8"));
     return !!content.servers?.["rrce"];
   } catch {
     return false;
   }
 }
 function checkOpenCodeConfig() {
-  if (!fs5.existsSync(OPENCODE_CONFIG)) return false;
+  if (!fs6.existsSync(OPENCODE_CONFIG)) return false;
   try {
-    const content = JSON.parse(fs5.readFileSync(OPENCODE_CONFIG, "utf-8"));
+    const content = JSON.parse(fs6.readFileSync(OPENCODE_CONFIG, "utf-8"));
     return !!content.mcp?.["rrce"];
   } catch {
     return false;
@@ -845,14 +933,14 @@ function installToConfig(target, workspacePath) {
   }
 }
 function installToAntigravity() {
-  const dir = path6.dirname(ANTIGRAVITY_CONFIG);
-  if (!fs5.existsSync(dir)) {
-    fs5.mkdirSync(dir, { recursive: true });
+  const dir = path7.dirname(ANTIGRAVITY_CONFIG);
+  if (!fs6.existsSync(dir)) {
+    fs6.mkdirSync(dir, { recursive: true });
   }
   let config = { mcpServers: {} };
-  if (fs5.existsSync(ANTIGRAVITY_CONFIG)) {
+  if (fs6.existsSync(ANTIGRAVITY_CONFIG)) {
     try {
-      config = JSON.parse(fs5.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
+      config = JSON.parse(fs6.readFileSync(ANTIGRAVITY_CONFIG, "utf-8"));
     } catch {
     }
   }
@@ -862,21 +950,21 @@ function installToAntigravity() {
     args: ["-y", "rrce-workflow", "mcp", "start"]
   };
   try {
-    fs5.writeFileSync(ANTIGRAVITY_CONFIG, JSON.stringify(config, null, 2));
+    fs6.writeFileSync(ANTIGRAVITY_CONFIG, JSON.stringify(config, null, 2));
     return true;
   } catch {
     return false;
   }
 }
 function installToClaude() {
-  const dir = path6.dirname(CLAUDE_CONFIG);
-  if (!fs5.existsSync(dir)) {
-    fs5.mkdirSync(dir, { recursive: true });
+  const dir = path7.dirname(CLAUDE_CONFIG);
+  if (!fs6.existsSync(dir)) {
+    fs6.mkdirSync(dir, { recursive: true });
   }
   let config = { mcpServers: {} };
-  if (fs5.existsSync(CLAUDE_CONFIG)) {
+  if (fs6.existsSync(CLAUDE_CONFIG)) {
     try {
-      config = JSON.parse(fs5.readFileSync(CLAUDE_CONFIG, "utf-8"));
+      config = JSON.parse(fs6.readFileSync(CLAUDE_CONFIG, "utf-8"));
     } catch {
     }
   }
@@ -886,21 +974,21 @@ function installToClaude() {
     args: ["-y", "rrce-workflow", "mcp", "start"]
   };
   try {
-    fs5.writeFileSync(CLAUDE_CONFIG, JSON.stringify(config, null, 2));
+    fs6.writeFileSync(CLAUDE_CONFIG, JSON.stringify(config, null, 2));
     return true;
   } catch {
     return false;
   }
 }
 function installToVSCodeGlobal() {
-  const dir = path6.dirname(VSCODE_GLOBAL_CONFIG);
-  if (!fs5.existsSync(dir)) {
-    fs5.mkdirSync(dir, { recursive: true });
+  const dir = path7.dirname(VSCODE_GLOBAL_CONFIG);
+  if (!fs6.existsSync(dir)) {
+    fs6.mkdirSync(dir, { recursive: true });
   }
   let settings = {};
-  if (fs5.existsSync(VSCODE_GLOBAL_CONFIG)) {
+  if (fs6.existsSync(VSCODE_GLOBAL_CONFIG)) {
     try {
-      settings = JSON.parse(fs5.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
+      settings = JSON.parse(fs6.readFileSync(VSCODE_GLOBAL_CONFIG, "utf-8"));
     } catch {
     }
   }
@@ -910,22 +998,22 @@ function installToVSCodeGlobal() {
     args: ["-y", "rrce-workflow", "mcp", "start"]
   };
   try {
-    fs5.writeFileSync(VSCODE_GLOBAL_CONFIG, JSON.stringify(settings, null, 2));
+    fs6.writeFileSync(VSCODE_GLOBAL_CONFIG, JSON.stringify(settings, null, 2));
     return true;
   } catch {
     return false;
   }
 }
 function installToVSCodeWorkspace(workspacePath) {
-  const vscodeDir = path6.join(workspacePath, ".vscode");
-  const configPath = path6.join(vscodeDir, "mcp.json");
-  if (!fs5.existsSync(vscodeDir)) {
-    fs5.mkdirSync(vscodeDir, { recursive: true });
+  const vscodeDir = path7.join(workspacePath, ".vscode");
+  const configPath = path7.join(vscodeDir, "mcp.json");
+  if (!fs6.existsSync(vscodeDir)) {
+    fs6.mkdirSync(vscodeDir, { recursive: true });
   }
   let config = { servers: {} };
-  if (fs5.existsSync(configPath)) {
+  if (fs6.existsSync(configPath)) {
     try {
-      config = JSON.parse(fs5.readFileSync(configPath, "utf-8"));
+      config = JSON.parse(fs6.readFileSync(configPath, "utf-8"));
     } catch {
     }
   }
@@ -935,23 +1023,23 @@ function installToVSCodeWorkspace(workspacePath) {
     args: ["-y", "rrce-workflow", "mcp", "start"]
   };
   try {
-    fs5.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    fs6.writeFileSync(configPath, JSON.stringify(config, null, 2));
     return true;
   } catch {
     return false;
   }
 }
 function installToOpenCode() {
-  const dir = path6.dirname(OPENCODE_CONFIG);
-  if (!fs5.existsSync(dir)) {
-    fs5.mkdirSync(dir, { recursive: true });
+  const dir = path7.dirname(OPENCODE_CONFIG);
+  if (!fs6.existsSync(dir)) {
+    fs6.mkdirSync(dir, { recursive: true });
   }
   let config = {
     $schema: "https://opencode.ai/config.json"
   };
-  if (fs5.existsSync(OPENCODE_CONFIG)) {
+  if (fs6.existsSync(OPENCODE_CONFIG)) {
     try {
-      config = JSON.parse(fs5.readFileSync(OPENCODE_CONFIG, "utf-8"));
+      config = JSON.parse(fs6.readFileSync(OPENCODE_CONFIG, "utf-8"));
     } catch (error) {
       console.error("Warning: Could not parse existing OpenCode config, creating fresh config");
     }
@@ -963,7 +1051,7 @@ function installToOpenCode() {
     enabled: true
   };
   try {
-    fs5.writeFileSync(OPENCODE_CONFIG, JSON.stringify(config, null, 2) + "\n");
+    fs6.writeFileSync(OPENCODE_CONFIG, JSON.stringify(config, null, 2) + "\n");
     return true;
   } catch (error) {
     console.error("Failed to write OpenCode config:", error instanceof Error ? error.message : String(error));
@@ -987,115 +1075,27 @@ function getTargetLabel(target) {
   }
 }
 function isOpenCodeInstalled() {
-  const configDir = path6.join(os.homedir(), ".config/opencode");
-  const configFile = path6.join(configDir, "opencode.json");
-  return fs5.existsSync(configDir) || fs5.existsSync(configFile);
+  const configDir = path7.join(os.homedir(), ".config/opencode");
+  const configFile = path7.join(configDir, "opencode.json");
+  return fs6.existsSync(configDir) || fs6.existsSync(configFile);
 }
 function isAntigravityInstalled() {
-  const configDir = path6.join(os.homedir(), ".gemini/antigravity");
-  return fs5.existsSync(configDir);
+  const configDir = path7.join(os.homedir(), ".gemini/antigravity");
+  return fs6.existsSync(configDir);
 }
 function isVSCodeInstalled() {
-  const configDir = path6.join(os.homedir(), ".config/Code/User");
-  return fs5.existsSync(configDir);
+  const configDir = path7.join(os.homedir(), ".config/Code/User");
+  return fs6.existsSync(configDir);
 }
 var ANTIGRAVITY_CONFIG, CLAUDE_CONFIG, VSCODE_GLOBAL_CONFIG, OPENCODE_CONFIG_DIR, OPENCODE_CONFIG;
 var init_install = __esm({
   "src/mcp/install.ts"() {
     "use strict";
-    ANTIGRAVITY_CONFIG = path6.join(os.homedir(), ".gemini/antigravity/mcp_config.json");
-    CLAUDE_CONFIG = path6.join(os.homedir(), ".config/claude/claude_desktop_config.json");
-    VSCODE_GLOBAL_CONFIG = path6.join(os.homedir(), ".config/Code/User/settings.json");
-    OPENCODE_CONFIG_DIR = path6.join(os.homedir(), ".config/opencode");
-    OPENCODE_CONFIG = path6.join(OPENCODE_CONFIG_DIR, "opencode.json");
-  }
-});
-
-// src/types/prompt.ts
-import { z } from "zod";
-var PromptArgSchema, AutoIdentitySchema, PromptFrontmatterSchema;
-var init_prompt = __esm({
-  "src/types/prompt.ts"() {
-    "use strict";
-    PromptArgSchema = z.object({
-      name: z.string(),
-      default: z.string().optional(),
-      prompt: z.string().optional()
-    });
-    AutoIdentitySchema = z.object({
-      user: z.string(),
-      model: z.string()
-    });
-    PromptFrontmatterSchema = z.object({
-      name: z.string(),
-      description: z.string(),
-      "argument-hint": z.union([z.string(), z.array(z.string())]).optional(),
-      tools: z.array(z.string()).optional(),
-      mode: z.enum(["primary", "subagent"]).optional(),
-      "required-args": z.array(PromptArgSchema).optional(),
-      "optional-args": z.array(PromptArgSchema).optional(),
-      "auto-identity": AutoIdentitySchema.optional()
-    });
-  }
-});
-
-// src/lib/prompts.ts
-import * as fs6 from "fs";
-import * as path7 from "path";
-import { fileURLToPath } from "url";
-import matter from "gray-matter";
-function parsePromptFile(filePath) {
-  try {
-    const fileContent = fs6.readFileSync(filePath, "utf-8");
-    const { data, content } = matter(fileContent);
-    const parsed = PromptFrontmatterSchema.safeParse(data);
-    if (!parsed.success) {
-      console.error(`Failed to parse frontmatter in ${filePath}:`, parsed.error);
-      return null;
-    }
-    return {
-      frontmatter: parsed.data,
-      content: content.trim(),
-      filePath
-    };
-  } catch (error) {
-    console.error(`Error reading prompt file ${filePath}:`, error);
-    return null;
-  }
-}
-function loadPromptsFromDir(dirPath) {
-  if (!fs6.existsSync(dirPath)) {
-    return [];
-  }
-  const files = fs6.readdirSync(dirPath).filter((f) => f.endsWith(".md"));
-  const prompts = [];
-  for (const file of files) {
-    const prompt = parsePromptFile(path7.join(dirPath, file));
-    if (prompt) {
-      prompts.push(prompt);
-    }
-  }
-  return prompts;
-}
-function getAgentCoreDir() {
-  if (__dirname.includes("/src/") || __dirname.includes("\\src\\")) {
-    if (fs6.existsSync(path7.join(process.cwd(), "agent-core"))) {
-      return path7.join(process.cwd(), "agent-core");
-    }
-    return path7.resolve(__dirname, "../..", "agent-core");
-  }
-  return path7.join(__dirname, "..", "agent-core");
-}
-function getAgentCorePromptsDir() {
-  return path7.join(getAgentCoreDir(), "prompts");
-}
-var __filename, __dirname;
-var init_prompts = __esm({
-  "src/lib/prompts.ts"() {
-    "use strict";
-    init_prompt();
-    __filename = fileURLToPath(import.meta.url);
-    __dirname = path7.dirname(__filename);
+    ANTIGRAVITY_CONFIG = path7.join(os.homedir(), ".gemini/antigravity/mcp_config.json");
+    CLAUDE_CONFIG = path7.join(os.homedir(), ".config/claude/claude_desktop_config.json");
+    VSCODE_GLOBAL_CONFIG = path7.join(os.homedir(), ".config/Code/User/settings.json");
+    OPENCODE_CONFIG_DIR = path7.join(os.homedir(), ".config/opencode");
+    OPENCODE_CONFIG = path7.join(OPENCODE_CONFIG_DIR, "opencode.json");
   }
 });
 
@@ -4015,7 +4015,7 @@ Hidden projects: ${projects.length - exposedCount}`,
 async function handleConfigureGlobalPath() {
   const { resolveGlobalPath: resolveGlobalPath2 } = await Promise.resolve().then(() => (init_tui_utils(), tui_utils_exports));
   const fs26 = await import("fs");
-  const path24 = await import("path");
+  const path25 = await import("path");
   note3(
     `MCP Hub requires a ${pc5.bold("global storage path")} to store its configuration
 and coordinate across projects.
@@ -4038,7 +4038,7 @@ locally in each project. MCP needs a central location.`,
       `${pc5.green("\u2713")} Global path configured: ${pc5.cyan(resolvedPath)}
 
 MCP config will be stored at:
-${path24.join(resolvedPath, "mcp.yaml")}`,
+${path25.join(resolvedPath, "mcp.yaml")}`,
       "Configuration Saved"
     );
     return true;
@@ -5510,6 +5510,7 @@ var init_mcp = __esm({
 // src/commands/wizard/update-flow.ts
 var update_flow_exports = {};
 __export(update_flow_exports, {
+  runSilentUpdate: () => runSilentUpdate,
   runUpdateFlow: () => runUpdateFlow
 });
 import { confirm as confirm5, spinner as spinner2, note as note6, outro as outro2, cancel as cancel2, isCancel as isCancel7 } from "@clack/prompts";
@@ -5540,6 +5541,126 @@ function getPackageVersion2() {
   }
   return "0.0.0";
 }
+async function performUpdate(workspacePath, workspaceName, currentStorageMode, options = {}) {
+  const agentCoreDir = getAgentCoreDir();
+  const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
+  const runningVersion = getPackageVersion2();
+  const mode = currentStorageMode || "global";
+  const customGlobalPath = getEffectiveRRCEHome(workspacePath);
+  const dataPaths = resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspacePath, customGlobalPath);
+  const configFilePath = getConfigPath(workspacePath);
+  let currentSyncedVersion;
+  if (fs21.existsSync(configFilePath)) {
+    try {
+      const content = fs21.readFileSync(configFilePath, "utf-8");
+      const config = parse(content);
+      currentSyncedVersion = config.last_synced_version;
+    } catch (e) {
+    }
+  }
+  const driftReport = DriftService.checkDrift(dataPaths[0], currentSyncedVersion, runningVersion);
+  const ideTargets = [];
+  if (fs21.existsSync(configFilePath)) {
+    const configContent = fs21.readFileSync(configFilePath, "utf-8");
+    if (configContent.includes("opencode: true")) ideTargets.push("OpenCode agents");
+    if (configContent.includes("copilot: true")) ideTargets.push("GitHub Copilot");
+    if (configContent.includes("antigravity: true")) ideTargets.push("Antigravity");
+  }
+  for (const dataPath of dataPaths) {
+    const dirs = ["templates", "prompts", "docs"];
+    const updatedFiles = [];
+    for (const dir of dirs) {
+      const srcDir = path22.join(agentCoreDir, dir);
+      if (!fs21.existsSync(srcDir)) continue;
+      const syncFiles = (src, rel) => {
+        const entries = fs21.readdirSync(src, { withFileTypes: true });
+        for (const entry of entries) {
+          const entrySrc = path22.join(src, entry.name);
+          const entryRel = path22.join(rel, entry.name);
+          const entryDest = path22.join(dataPath, entryRel);
+          if (entry.isDirectory()) {
+            ensureDir(entryDest);
+            syncFiles(entrySrc, entryRel);
+          } else {
+            if (driftReport.modifiedFiles.includes(entryRel)) {
+              backupFile(entryDest);
+            }
+            fs21.copyFileSync(entrySrc, entryDest);
+            updatedFiles.push(entryRel);
+          }
+        }
+      };
+      syncFiles(srcDir, dir);
+    }
+    const manifest = DriftService.generateManifest(dataPath, updatedFiles);
+    DriftService.saveManifest(dataPath, manifest);
+  }
+  const rrceHome = customGlobalPath || getDefaultRRCEHome2();
+  ensureDir(path22.join(rrceHome, "templates"));
+  ensureDir(path22.join(rrceHome, "docs"));
+  copyDirRecursive(path22.join(agentCoreDir, "templates"), path22.join(rrceHome, "templates"));
+  copyDirRecursive(path22.join(agentCoreDir, "docs"), path22.join(rrceHome, "docs"));
+  if (fs21.existsSync(configFilePath)) {
+    const configContent = fs21.readFileSync(configFilePath, "utf-8");
+    if (configContent.includes("copilot: true")) {
+      const copilotPath = getAgentPromptPath(workspacePath, "copilot");
+      ensureDir(copilotPath);
+      clearDirectory(copilotPath);
+      copyPromptsToDir(prompts, copilotPath, ".agent.md");
+    }
+    if (configContent.includes("antigravity: true")) {
+      const antigravityPath = getAgentPromptPath(workspacePath, "antigravity");
+      ensureDir(antigravityPath);
+      clearDirectory(antigravityPath);
+      copyPromptsToDir(prompts, antigravityPath, ".md");
+    }
+    if (configContent.includes("opencode: true")) {
+      const primaryDataPath = dataPaths[0];
+      if (primaryDataPath) {
+        surgicalUpdateOpenCodeAgents(prompts, mode, primaryDataPath);
+      }
+    }
+    try {
+      const yaml = parse(configContent);
+      yaml.last_synced_version = runningVersion;
+      fs21.writeFileSync(configFilePath, stringify2(yaml));
+    } catch (e) {
+      console.error("Failed to update config.yaml version:", e);
+    }
+  }
+  const mcpPath = path22.join(rrceHome, "mcp.yaml");
+  if (fs21.existsSync(mcpPath)) {
+    try {
+      const content = fs21.readFileSync(mcpPath, "utf-8");
+      const yaml = parse(content);
+      if (yaml.projects) {
+        const project = yaml.projects.find((p) => p.name === workspaceName);
+        if (project) {
+          project.last_synced_version = runningVersion;
+          fs21.writeFileSync(mcpPath, stringify2(yaml));
+        }
+      }
+    } catch (e) {
+      console.error("Failed to update mcp.yaml version:", e);
+    }
+  }
+  return {
+    success: true,
+    ideTargets,
+    modifiedFiles: driftReport.modifiedFiles
+  };
+}
+async function runSilentUpdate(workspacePath, workspaceName, currentStorageMode) {
+  const s = spinner2();
+  s.start("Applying updates...");
+  try {
+    await performUpdate(workspacePath, workspaceName, currentStorageMode, { silent: true });
+    s.stop("Updates applied");
+  } catch (error) {
+    s.stop("Update failed");
+    throw error;
+  }
+}
 async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
   const s = spinner2();
   s.start("Checking for updates");
@@ -5732,9 +5853,11 @@ var init_update_flow = __esm({
 });
 
 // src/commands/wizard/index.ts
-import { intro as intro2, select as select5, spinner as spinner7, note as note11, outro as outro7, isCancel as isCancel12 } from "@clack/prompts";
+import { intro as intro2, select as select5, spinner as spinner7, note as note11, outro as outro7, isCancel as isCancel12, confirm as confirm10 } from "@clack/prompts";
 import pc13 from "picocolors";
 import * as fs25 from "fs";
+import * as path24 from "path";
+import { parse as parse2 } from "yaml";
 
 // src/lib/git.ts
 import { execSync } from "child_process";
@@ -5750,6 +5873,7 @@ function getGitUser() {
 // src/commands/wizard/index.ts
 init_paths();
 init_detection_service();
+init_prompts();
 
 // src/commands/wizard/setup-flow.ts
 import { spinner as spinner3, note as note7, outro as outro3, cancel as cancel3, isCancel as isCancel8, confirm as confirm6, select as select3 } from "@clack/prompts";
@@ -6637,6 +6761,76 @@ Are you sure?`,
 // src/commands/wizard/index.ts
 init_mcp();
 init_config();
+function getPackageVersion3() {
+  try {
+    const agentCoreDir = getAgentCoreDir();
+    const packageJsonPath = path24.join(path24.dirname(agentCoreDir), "package.json");
+    if (fs25.existsSync(packageJsonPath)) {
+      return JSON.parse(fs25.readFileSync(packageJsonPath, "utf8")).version;
+    }
+  } catch (e) {
+  }
+  return "0.0.0";
+}
+function getLastSyncedVersion(workspacePath, workspaceName) {
+  const configFilePath = getConfigPath(workspacePath);
+  if (fs25.existsSync(configFilePath)) {
+    try {
+      const content = fs25.readFileSync(configFilePath, "utf-8");
+      const config = parse2(content);
+      if (config.last_synced_version) {
+        return config.last_synced_version;
+      }
+    } catch (e) {
+    }
+  }
+  const rrceHome = getEffectiveRRCEHome(workspacePath) || getDefaultRRCEHome2();
+  const mcpPath = path24.join(rrceHome, "mcp.yaml");
+  if (fs25.existsSync(mcpPath)) {
+    try {
+      const content = fs25.readFileSync(mcpPath, "utf-8");
+      const config = parse2(content);
+      const project = config.projects?.find((p) => p.name === workspaceName);
+      if (project?.last_synced_version) {
+        return project.last_synced_version;
+      }
+    } catch (e) {
+    }
+  }
+  return void 0;
+}
+async function checkAndPromptUpdate(workspacePath, workspaceName, currentStorageMode) {
+  const runningVersion = getPackageVersion3();
+  const lastSyncedVersion = getLastSyncedVersion(workspacePath, workspaceName);
+  if (lastSyncedVersion === runningVersion) {
+    return true;
+  }
+  const versionInfo = lastSyncedVersion ? `${pc13.dim(lastSyncedVersion)} \u2192 ${pc13.green(runningVersion)}` : `${pc13.dim("unknown")} \u2192 ${pc13.green(runningVersion)}`;
+  note11(
+    `${pc13.bold(pc13.cyan("Update available!"))} ${versionInfo}
+
+New prompts, templates, and agent improvements are ready to install.
+Your custom knowledge and configuration will be preserved.`,
+    "\u{1F4E6} Version Update"
+  );
+  const shouldUpdate = await confirm10({
+    message: "Apply update now?",
+    initialValue: true
+  });
+  if (isCancel12(shouldUpdate)) {
+    return false;
+  }
+  if (shouldUpdate) {
+    await runSilentUpdate(workspacePath, workspaceName, currentStorageMode);
+    note11(
+      `${pc13.green("\u2713")} Updated to version ${pc13.bold(runningVersion)}
+
+All agent prompts, templates, and IDE integrations have been synced.`,
+      "Update Complete"
+    );
+  }
+  return true;
+}
 async function runWizard() {
   intro2(pc13.cyan(pc13.inverse(" RRCE-Workflow Setup ")));
   const s = spinner7();
@@ -6687,24 +6881,22 @@ Workspace: ${pc13.bold(workspaceName)}`,
   const localDataPath = getLocalWorkspacePath(workspacePath);
   const hasLocalData = fs25.existsSync(localDataPath);
   if (isAlreadyConfigured) {
+    const continueToMenu = await checkAndPromptUpdate(workspacePath, workspaceName, currentStorageMode);
+    if (!continueToMenu) {
+      outro7("Exited.");
+      process.exit(0);
+    }
     const menuOptions = [];
     menuOptions.push({
       value: "mcp",
-      label: "\u{1F50C} Configure MCP Server",
-      hint: "Expose projects to AI assistants (VSCode, Antigravity, Claude)"
+      label: "\u{1F50C} MCP Dashboard",
+      hint: "Manage projects & AI integrations"
     });
-    if (detectedProjects.some((p) => p.source === "global")) {
-      menuOptions.push({
-        value: "delete-global",
-        label: "\u{1F5D1}\uFE0F  Delete global project(s)",
-        hint: "Remove knowledge and configuration"
-      });
-    }
-    if (detectedProjects.length > 0) {
+    if (detectedProjects.some((p) => p.source === "global") || detectedProjects.length > 0) {
       menuOptions.push({
-        value: "link",
-        label: "\u{1F517} Link other project knowledge",
-        hint: `${detectedProjects.length} projects detected (global + sibling)`
+        value: "manage",
+        label: "\u{1F4C1} Manage Projects",
+        hint: "Link, delete, or sync projects"
       });
     }
     if (currentStorageMode === "workspace" && hasLocalData) {
@@ -6714,11 +6906,10 @@ Workspace: ${pc13.bold(workspaceName)}`,
         hint: "Share knowledge with other projects"
       });
     }
-    menuOptions.push({ value: "update", label: "\u{1F4E6} Update from package", hint: "Get latest prompts & templates" });
-    menuOptions.push({ value: "reconfigure", label: "\u{1F527} Reconfigure project", hint: "Change storage mode, tools, etc." });
+    menuOptions.push({ value: "advanced", label: "\u2699\uFE0F  Advanced", hint: "Update, reconfigure, or troubleshoot" });
     menuOptions.push({ value: "exit", label: "\u21A9  Exit" });
     const action = await select5({
-      message: "This workspace is already configured. What would you like to do?",
+      message: "What would you like to do?",
       options: menuOptions
     });
     if (isCancel12(action) || action === "exit") {
@@ -6729,23 +6920,62 @@ Workspace: ${pc13.bold(workspaceName)}`,
       await runMCP();
       return;
     }
-    if (action === "delete-global") {
-      await runDeleteGlobalProjectFlow(detectedProjects);
-      return;
-    }
-    if (action === "link") {
-      await runLinkProjectsFlow(workspacePath, workspaceName);
-      return;
+    if (action === "manage") {
+      const manageOptions = [];
+      if (detectedProjects.some((p) => p.source === "global")) {
+        manageOptions.push({
+          value: "delete-global",
+          label: "\u{1F5D1}\uFE0F  Delete global project(s)",
+          hint: "Remove knowledge and configuration"
+        });
+      }
+      if (detectedProjects.length > 0) {
+        manageOptions.push({
+          value: "link",
+          label: "\u{1F517} Link other project knowledge",
+          hint: `${detectedProjects.length} projects detected`
+        });
+      }
+      manageOptions.push({ value: "back", label: "\u21A9  Back to main menu" });
+      const manageAction = await select5({
+        message: "Project Management",
+        options: manageOptions
+      });
+      if (isCancel12(manageAction) || manageAction === "back") {
+        return runWizard();
+      }
+      if (manageAction === "delete-global") {
+        await runDeleteGlobalProjectFlow(detectedProjects);
+        return;
+      }
+      if (manageAction === "link") {
+        await runLinkProjectsFlow(workspacePath, workspaceName);
+        return;
+      }
     }
     if (action === "sync-global") {
       await runSyncToGlobalFlow(workspacePath, workspaceName);
       return;
     }
-    if (action === "update") {
-      await runUpdateFlow(workspacePath, workspaceName, currentStorageMode);
-      return;
-    }
-    if (action === "reconfigure") {
+    if (action === "advanced") {
+      const advancedOptions = [
+        { value: "update", label: "\u{1F4E6} Manual Update", hint: "Force update from package" },
+        { value: "reconfigure", label: "\u{1F527} Reconfigure Project", hint: "Change storage mode, tools, etc." },
+        { value: "back", label: "\u21A9  Back to main menu" }
+      ];
+      const advancedAction = await select5({
+        message: "Advanced Options",
+        options: advancedOptions
+      });
+      if (isCancel12(advancedAction) || advancedAction === "back") {
+        return runWizard();
+      }
+      if (advancedAction === "update") {
+        await runUpdateFlow(workspacePath, workspaceName, currentStorageMode);
+        return;
+      }
+      if (advancedAction === "reconfigure") {
+      }
     }
   }
   await runSetupFlow(workspacePath, workspaceName, detectedProjects);

package/package.json

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