rrce-workflow 0.3.37 → 0.3.38

package/README.md

@@ -29,6 +29,11 @@ cd your-project
 npx rrce-workflow
 ```
 
+Alias:
+```bash
+npx rrce-workflow install
+```
+
 This launches the setup wizard and can:
 - Create the `.rrce-workflow/` structure (workspace mode) or initialize global storage (global mode)
 - Install IDE integrations (VSCode / Claude Desktop / OpenCode / Antigravity)

package/dist/index.js

@@ -1728,6 +1728,8 @@ var init_logger = __esm({
     init_paths();
     Logger = class {
       logPath;
+      maxBytes = 2 * 1024 * 1024;
+      trimToBytes = 512 * 1024;
       constructor() {
         this.logPath = getLogFilePath();
       }
@@ -1754,12 +1756,30 @@ ${JSON.stringify(data, null, 2)}`;
           if (!fs13.existsSync(dir)) {
             fs13.mkdirSync(dir, { recursive: true });
           }
+          this.trimIfNeeded();
           fs13.appendFileSync(this.logPath, logMessage);
         } catch (e) {
           console.error(`[Logger Failure] Could not write to ${this.logPath}`, e);
           console.error(logMessage);
         }
       }
+      trimIfNeeded() {
+        try {
+          if (!fs13.existsSync(this.logPath)) return;
+          const stats = fs13.statSync(this.logPath);
+          if (stats.size <= this.maxBytes) return;
+          const start = Math.max(0, stats.size - this.trimToBytes);
+          const fd = fs13.openSync(this.logPath, "r");
+          const buffer = Buffer.alloc(stats.size - start);
+          fs13.readSync(fd, buffer, 0, buffer.length, start);
+          fs13.closeSync(fd);
+          const header = `[${(/* @__PURE__ */ new Date()).toISOString()}] [INFO] Log truncated to last ${this.trimToBytes} bytes
+`;
+          fs13.writeFileSync(this.logPath, header + buffer.toString("utf-8"));
+        } catch (e) {
+          console.error(`[Logger Failure] Could not trim ${this.logPath}`, e);
+        }
+      }
       info(message, data) {
         this.write("INFO", message, data);
       }
@@ -1924,6 +1944,13 @@ function resolveProjectPaths(project, pathInput) {
     const projConfig = findProjectConfig(config, { name: project });
     if (projConfig?.path) {
       workspaceRoot = projConfig.path;
+    } else {
+      const knownProjects = config.projects.filter((p) => !!p.path).map((p) => ({ name: p.name, path: p.path }));
+      const projects = projectService.scan({ knownProjects });
+      const match = projects.find((p) => p.name === project);
+      if (match) {
+        workspaceRoot = match.sourcePath || match.path;
+      }
     }
   }
   if (workspaceRoot && workspaceRoot.includes("/workspaces/")) {
@@ -1941,7 +1968,14 @@ function resolveProjectPaths(project, pathInput) {
   }
   if (!workspaceName && workspaceRoot) {
     const projConfig = findProjectConfig(config, { path: workspaceRoot });
-    workspaceName = projConfig?.name || getWorkspaceName(workspaceRoot);
+    if (projConfig?.name) {
+      workspaceName = projConfig.name;
+    } else {
+      const knownProjects = config.projects.filter((p) => !!p.path).map((p) => ({ name: p.name, path: p.path }));
+      const projects = projectService.scan({ knownProjects });
+      const closest = findClosestProject(projects, workspaceRoot);
+      workspaceName = closest?.name || getWorkspaceName(workspaceRoot);
+    }
   }
   if (!workspaceName) {
     workspaceName = "unknown";
@@ -1980,6 +2014,8 @@ var init_paths2 = __esm({
     "use strict";
     init_config();
     init_config_utils();
+    init_detection_service();
+    init_detection();
     init_paths();
   }
 });
@@ -5448,6 +5484,7 @@ import {
   ListToolsRequestSchema,
   CallToolRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
+import * as path29 from "path";
 function registerToolHandlers(server) {
   server.setRequestHandler(ListToolsRequestSchema, async () => {
     const tools = [
@@ -5470,19 +5507,20 @@ function registerToolHandlers(server) {
   });
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
-    logger.info(`Calling tool: ${name}`, args);
+    const argsWithCaller = applyCallerContext(name, args, request);
+    logger.info(`Calling tool: ${name}`, argsWithCaller);
     try {
-      const projectResult = await handleProjectTool(name, args);
+      const projectResult = await handleProjectTool(name, argsWithCaller);
       if (projectResult) return projectResult;
-      const searchResult = await handleSearchTool(name, args);
+      const searchResult = await handleSearchTool(name, argsWithCaller);
       if (searchResult) return searchResult;
-      const taskResult = await handleTaskTool(name, args);
+      const taskResult = await handleTaskTool(name, argsWithCaller);
       if (taskResult) return taskResult;
-      const sessionResult = await handleSessionTool(name, args);
+      const sessionResult = await handleSessionTool(name, argsWithCaller);
       if (sessionResult) return sessionResult;
-      const agentResult = await handleAgentTool(name, args);
+      const agentResult = await handleAgentTool(name, argsWithCaller);
       if (agentResult) return agentResult;
-      const cleanupResult = await handleCleanupTool(name, args);
+      const cleanupResult = await handleCleanupTool(name, argsWithCaller);
       if (cleanupResult) return cleanupResult;
       throw new Error(`Unknown tool: ${name}`);
     } catch (error) {
@@ -5491,11 +5529,72 @@ function registerToolHandlers(server) {
     }
   });
 }
+function applyCallerContext(toolName, args, request) {
+  const callerPath = getCallerPath(request);
+  if (!callerPath) return args;
+  const callerProject = resolveCallerProject(callerPath);
+  if (!callerProject) return args;
+  const nextArgs = { ...args || {} };
+  if (!nextArgs.project && callerProject.project) {
+    nextArgs.project = callerProject.project;
+  }
+  if (!nextArgs.path && toolName === "resolve_path" && callerProject.path) {
+    nextArgs.path = callerProject.path;
+  }
+  return nextArgs;
+}
+function getCallerPath(request) {
+  const params = request.params;
+  const meta = params?._meta || request._meta || request.meta;
+  const caller = meta?.caller || meta?.client || meta?.source || meta?.requester || meta;
+  const candidates = [
+    caller?.workspaceRoot,
+    caller?.workspace_root,
+    caller?.projectPath,
+    caller?.project_path,
+    caller?.cwd,
+    caller?.root,
+    caller?.path,
+    meta?.workspaceRoot,
+    meta?.workspace_root,
+    meta?.projectPath,
+    meta?.project_path,
+    meta?.cwd,
+    meta?.root,
+    meta?.path
+  ];
+  for (const value of candidates) {
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value.trim();
+    }
+  }
+  return void 0;
+}
+function resolveCallerProject(callerPath) {
+  const config = configService.load();
+  const knownProjects = config.projects.filter((p) => !!p.path).map((p) => ({ name: p.name, path: p.path }));
+  const projects = projectService.scan({ knownProjects });
+  const exposed = projects.filter((p) => isProjectExposed(config, p.name, p.sourcePath || p.path));
+  const closest = findClosestProject(exposed, callerPath);
+  if (closest) {
+    return { project: closest.name, path: closest.sourcePath || closest.path };
+  }
+  if (callerPath) {
+    const fallbackName = path29.basename(callerPath);
+    if (fallbackName) {
+      return { project: fallbackName, path: callerPath };
+    }
+  }
+  return void 0;
+}
 var init_tools = __esm({
   "src/mcp/handlers/tools.ts"() {
     "use strict";
     init_logger();
     init_resources2();
+    init_config();
+    init_detection_service();
+    init_detection();
     init_project();
     init_search2();
     init_task();
@@ -5748,7 +5847,7 @@ Hidden projects: ${projects.length - exposedCount}`,
 async function handleConfigureGlobalPath() {
   const { resolveGlobalPath: resolveGlobalPath2 } = await Promise.resolve().then(() => (init_tui_utils(), tui_utils_exports));
   const fs36 = await import("fs");
-  const path35 = await import("path");
+  const path36 = await import("path");
   note3(
     `MCP Hub requires a ${pc5.bold("global storage path")} to store its configuration
 and coordinate across projects.
@@ -5771,7 +5870,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:
-${path35.join(resolvedPath, "mcp.yaml")}`,
+${path36.join(resolvedPath, "mcp.yaml")}`,
       "Configuration Saved"
     );
     return true;
@@ -5876,12 +5975,12 @@ __export(ConfigContext_exports, {
 });
 import { createContext, useContext, useState, useCallback, useMemo, useEffect } from "react";
 import * as fs27 from "fs";
-import * as path29 from "path";
+import * as path30 from "path";
 import { jsx as jsx2 } from "react/jsx-runtime";
 function getPackageVersion() {
   try {
     const agentCoreDir = getAgentCoreDir();
-    const packageJsonPath = path29.join(path29.dirname(agentCoreDir), "package.json");
+    const packageJsonPath = path30.join(path30.dirname(agentCoreDir), "package.json");
     if (fs27.existsSync(packageJsonPath)) {
       return JSON.parse(fs27.readFileSync(packageJsonPath, "utf8")).version;
     }
@@ -5951,10 +6050,10 @@ var init_ConfigContext = __esm({
 
 // src/mcp/ui/lib/tasks-fs.ts
 import * as fs28 from "fs";
-import * as path30 from "path";
+import * as path31 from "path";
 function readSession(project, taskSlug) {
   const rrceData = getProjectRRCEData(project);
-  const sessionPath = path30.join(rrceData, "tasks", taskSlug, "session.json");
+  const sessionPath = path31.join(rrceData, "tasks", taskSlug, "session.json");
   if (!fs28.existsSync(sessionPath)) {
     return null;
   }
@@ -5972,7 +6071,7 @@ function isSessionStale(session, thresholdMs = SESSION_STALE_THRESHOLD_MS) {
 }
 function readAgentTodos(project, taskSlug) {
   const rrceData = getProjectRRCEData(project);
-  const todosPath = path30.join(rrceData, "tasks", taskSlug, "agent-todos.json");
+  const todosPath = path31.join(rrceData, "tasks", taskSlug, "agent-todos.json");
   if (!fs28.existsSync(todosPath)) {
     return null;
   }
@@ -6001,7 +6100,7 @@ function detectStorageModeFromConfig(workspaceRoot) {
 }
 function getEffectiveGlobalBase() {
   const dummy = resolveDataPath("global", "__rrce_dummy__", "");
-  return path30.dirname(path30.dirname(dummy));
+  return path31.dirname(path31.dirname(dummy));
 }
 function getProjectRRCEData(project) {
   const workspaceRoot = project.sourcePath || project.path;
@@ -6010,7 +6109,7 @@ function getProjectRRCEData(project) {
 }
 function listProjectTasks(project) {
   const rrceData = getProjectRRCEData(project);
-  const tasksPath = path30.join(rrceData, "tasks");
+  const tasksPath = path31.join(rrceData, "tasks");
   if (!fs28.existsSync(tasksPath)) {
     return { projectName: project.name, tasksPath, tasks: [] };
   }
@@ -6019,7 +6118,7 @@ function listProjectTasks(project) {
     const entries = fs28.readdirSync(tasksPath, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const metaPath = path30.join(tasksPath, entry.name, "meta.json");
+      const metaPath = path31.join(tasksPath, entry.name, "meta.json");
       if (!fs28.existsSync(metaPath)) continue;
       try {
         const raw = fs28.readFileSync(metaPath, "utf-8");
@@ -6041,7 +6140,7 @@ function listProjectTasks(project) {
 }
 function updateTaskStatus(project, taskSlug, status) {
   const rrceData = getProjectRRCEData(project);
-  const metaPath = path30.join(rrceData, "tasks", taskSlug, "meta.json");
+  const metaPath = path31.join(rrceData, "tasks", taskSlug, "meta.json");
   if (!fs28.existsSync(metaPath)) {
     return { ok: false, error: `meta.json not found for task '${taskSlug}'` };
   }
@@ -6438,14 +6537,14 @@ var init_ProjectViews = __esm({
 
 // src/mcp/ui/lib/projects.ts
 import * as fs29 from "fs";
-import * as path31 from "path";
+import * as path32 from "path";
 function getIndexStats(project) {
   const stats = { knowledgeCount: 0, codeCount: 0, lastIndexed: null };
   try {
     const knowledgePath = project.knowledgePath;
     if (knowledgePath) {
-      const embPath = path31.join(knowledgePath, "embeddings.json");
-      const codeEmbPath = path31.join(knowledgePath, "code-embeddings.json");
+      const embPath = path32.join(knowledgePath, "embeddings.json");
+      const codeEmbPath = path32.join(knowledgePath, "code-embeddings.json");
       if (fs29.existsSync(embPath)) {
         const stat = fs29.statSync(embPath);
         stats.lastIndexed = stat.mtime.toISOString();
@@ -7274,27 +7373,46 @@ var init_App = __esm({
       }, []);
       useEffect6(() => {
         const logPath = getLogFilePath();
+        const maxLines = 100;
+        const tailBytes = 64 * 1024;
         let lastSize = 0;
-        if (fs30.existsSync(logPath)) {
+        const loadTail = () => {
+          if (!fs30.existsSync(logPath)) {
+            setLogs([]);
+            lastSize = 0;
+            return;
+          }
           const stats = fs30.statSync(logPath);
+          const start = Math.max(0, stats.size - tailBytes);
+          const buffer = Buffer.alloc(stats.size - start);
+          const fd = fs30.openSync(logPath, "r");
+          fs30.readSync(fd, buffer, 0, buffer.length, start);
+          fs30.closeSync(fd);
+          const content = buffer.toString("utf-8");
+          const lines = content.split("\n").filter((l) => l.trim());
+          setLogs(lines.slice(-maxLines));
           lastSize = stats.size;
-        }
+        };
+        loadTail();
         const interval = setInterval(() => {
-          if (fs30.existsSync(logPath)) {
-            const stats = fs30.statSync(logPath);
-            if (stats.size > lastSize) {
-              const buffer = Buffer.alloc(stats.size - lastSize);
-              const fd = fs30.openSync(logPath, "r");
-              fs30.readSync(fd, buffer, 0, buffer.length, lastSize);
-              fs30.closeSync(fd);
-              const newContent = buffer.toString("utf-8");
-              const newLines = newContent.split("\n").filter((l) => l.trim());
-              setLogs((prev) => {
-                const next = [...prev, ...newLines];
-                return next.slice(-100);
-              });
-              lastSize = stats.size;
-            }
+          if (!fs30.existsSync(logPath)) return;
+          const stats = fs30.statSync(logPath);
+          if (stats.size < lastSize) {
+            loadTail();
+            return;
+          }
+          if (stats.size > lastSize) {
+            const buffer = Buffer.alloc(stats.size - lastSize);
+            const fd = fs30.openSync(logPath, "r");
+            fs30.readSync(fd, buffer, 0, buffer.length, lastSize);
+            fs30.closeSync(fd);
+            const newContent = buffer.toString("utf-8");
+            const newLines = newContent.split("\n").filter((l) => l.trim());
+            setLogs((prev) => {
+              const next = [...prev, ...newLines];
+              return next.slice(-maxLines);
+            });
+            lastSize = stats.size;
           }
         }, 500);
         return () => clearInterval(interval);
@@ -7512,8 +7630,38 @@ __export(update_flow_exports, {
 import { confirm as confirm5, spinner as spinner2, note as note6, outro as outro2, cancel as cancel2, isCancel as isCancel7 } from "@clack/prompts";
 import pc8 from "picocolors";
 import * as fs31 from "fs";
-import * as path32 from "path";
+import * as path33 from "path";
 import { stringify as stringify2, parse } from "yaml";
+async function ensureWorkspaceRootRegistration(workspacePath, workspaceName, configFilePath) {
+  if (!fs31.existsSync(configFilePath)) {
+    return;
+  }
+  let updatedConfig = false;
+  try {
+    const content = fs31.readFileSync(configFilePath, "utf-8");
+    const yaml = parse(content);
+    if (!yaml.project) {
+      yaml.project = { name: workspaceName, sourcePath: workspacePath };
+      updatedConfig = true;
+    } else if (!yaml.project.sourcePath) {
+      yaml.project.sourcePath = workspacePath;
+      updatedConfig = true;
+    }
+    if (updatedConfig) {
+      fs31.writeFileSync(configFilePath, stringify2(yaml));
+    }
+  } catch (e) {
+    console.error("Failed to update config.yaml sourcePath:", e);
+  }
+  try {
+    const { loadMCPConfig: loadMCPConfig2, saveMCPConfig: saveMCPConfig2, setProjectConfig: setProjectConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    const mcpConfig = loadMCPConfig2();
+    setProjectConfig2(mcpConfig, workspaceName, true, void 0, workspacePath);
+    saveMCPConfig2(mcpConfig);
+  } catch (e) {
+    console.error("Failed to update MCP config project path:", e);
+  }
+}
 function backupFile(filePath) {
   if (!fs31.existsSync(filePath)) return null;
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").split("T")[0] + "-" + Date.now();
@@ -7529,7 +7677,7 @@ function backupFile(filePath) {
 function getPackageVersion2() {
   try {
     const agentCoreDir = getAgentCoreDir();
-    const packageJsonPath = path32.join(path32.dirname(agentCoreDir), "package.json");
+    const packageJsonPath = path33.join(path33.dirname(agentCoreDir), "package.json");
     if (fs31.existsSync(packageJsonPath)) {
       return JSON.parse(fs31.readFileSync(packageJsonPath, "utf8")).version;
     }
@@ -7566,14 +7714,14 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
     const dirs = ["templates", "prompts", "docs"];
     const updatedFiles = [];
     for (const dir of dirs) {
-      const srcDir = path32.join(agentCoreDir, dir);
+      const srcDir = path33.join(agentCoreDir, dir);
       if (!fs31.existsSync(srcDir)) continue;
       const syncFiles = (src, rel) => {
         const entries = fs31.readdirSync(src, { withFileTypes: true });
         for (const entry of entries) {
-          const entrySrc = path32.join(src, entry.name);
-          const entryRel = path32.join(rel, entry.name);
-          const entryDest = path32.join(dataPath, entryRel);
+          const entrySrc = path33.join(src, entry.name);
+          const entryRel = path33.join(rel, entry.name);
+          const entryDest = path33.join(dataPath, entryRel);
           if (entry.isDirectory()) {
             ensureDir(entryDest);
             syncFiles(entrySrc, entryRel);
@@ -7581,7 +7729,7 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
             if (driftReport.modifiedFiles.includes(entryRel)) {
               backupFile(entryDest);
             }
-            ensureDir(path32.dirname(entryDest));
+            ensureDir(path33.dirname(entryDest));
             fs31.copyFileSync(entrySrc, entryDest);
             updatedFiles.push(entryRel);
           }
@@ -7593,10 +7741,10 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
     DriftService.saveManifest(dataPath, manifest);
   }
   const rrceHome = customGlobalPath || getDefaultRRCEHome2();
-  ensureDir(path32.join(rrceHome, "templates"));
-  ensureDir(path32.join(rrceHome, "docs"));
-  copyDirRecursive(path32.join(agentCoreDir, "templates"), path32.join(rrceHome, "templates"));
-  copyDirRecursive(path32.join(agentCoreDir, "docs"), path32.join(rrceHome, "docs"));
+  ensureDir(path33.join(rrceHome, "templates"));
+  ensureDir(path33.join(rrceHome, "docs"));
+  copyDirRecursive(path33.join(agentCoreDir, "templates"), path33.join(rrceHome, "templates"));
+  copyDirRecursive(path33.join(agentCoreDir, "docs"), path33.join(rrceHome, "docs"));
   if (fs31.existsSync(configFilePath)) {
     const configContent = fs31.readFileSync(configFilePath, "utf-8");
     if (configContent.includes("copilot: true")) {
@@ -7625,7 +7773,8 @@ async function performUpdate(workspacePath, workspaceName, currentStorageMode, o
       console.error("Failed to update config.yaml version:", e);
     }
   }
-  const mcpPath = path32.join(rrceHome, "mcp.yaml");
+  await ensureWorkspaceRootRegistration(workspacePath, workspaceName, configFilePath);
+  const mcpPath = path33.join(rrceHome, "mcp.yaml");
   if (fs31.existsSync(mcpPath)) {
     try {
       const content = fs31.readFileSync(mcpPath, "utf-8");
@@ -7726,14 +7875,14 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
       const dirs = ["templates", "prompts", "docs"];
       const updatedFiles = [];
       for (const dir of dirs) {
-        const srcDir = path32.join(agentCoreDir, dir);
+        const srcDir = path33.join(agentCoreDir, dir);
         if (!fs31.existsSync(srcDir)) continue;
         const syncFiles = (src, rel) => {
           const entries = fs31.readdirSync(src, { withFileTypes: true });
           for (const entry of entries) {
-            const entrySrc = path32.join(src, entry.name);
-            const entryRel = path32.join(rel, entry.name);
-            const entryDest = path32.join(dataPath, entryRel);
+            const entrySrc = path33.join(src, entry.name);
+            const entryRel = path33.join(rel, entry.name);
+            const entryDest = path33.join(dataPath, entryRel);
             if (entry.isDirectory()) {
               ensureDir(entryDest);
               syncFiles(entrySrc, entryRel);
@@ -7741,7 +7890,7 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
               if (driftReport.modifiedFiles.includes(entryRel)) {
                 backupFile(entryDest);
               }
-              ensureDir(path32.dirname(entryDest));
+              ensureDir(path33.dirname(entryDest));
               fs31.copyFileSync(entrySrc, entryDest);
               updatedFiles.push(entryRel);
             }
@@ -7753,10 +7902,10 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
       DriftService.saveManifest(dataPath, manifest);
     }
     const rrceHome = customGlobalPath || getDefaultRRCEHome2();
-    ensureDir(path32.join(rrceHome, "templates"));
-    ensureDir(path32.join(rrceHome, "docs"));
-    copyDirRecursive(path32.join(agentCoreDir, "templates"), path32.join(rrceHome, "templates"));
-    copyDirRecursive(path32.join(agentCoreDir, "docs"), path32.join(rrceHome, "docs"));
+    ensureDir(path33.join(rrceHome, "templates"));
+    ensureDir(path33.join(rrceHome, "docs"));
+    copyDirRecursive(path33.join(agentCoreDir, "templates"), path33.join(rrceHome, "templates"));
+    copyDirRecursive(path33.join(agentCoreDir, "docs"), path33.join(rrceHome, "docs"));
     if (fs31.existsSync(configFilePath)) {
       const configContent = fs31.readFileSync(configFilePath, "utf-8");
       if (configContent.includes("copilot: true")) {
@@ -7785,7 +7934,8 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
         console.error("Failed to update config.yaml version:", e);
       }
     }
-    const mcpPath = path32.join(rrceHome, "mcp.yaml");
+    await ensureWorkspaceRootRegistration(workspacePath, workspaceName, configFilePath);
+    const mcpPath = path33.join(rrceHome, "mcp.yaml");
     if (fs31.existsSync(mcpPath)) {
       try {
         const content = fs31.readFileSync(mcpPath, "utf-8");
@@ -7829,8 +7979,8 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
   }
 }
 function resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspaceRoot, customGlobalPath) {
-  const globalPath = path32.join(customGlobalPath, "workspaces", workspaceName);
-  const workspacePath = path32.join(workspaceRoot, ".rrce-workflow");
+  const globalPath = path33.join(customGlobalPath, "workspaces", workspaceName);
+  const workspacePath = path33.join(workspaceRoot, ".rrce-workflow");
   switch (mode) {
     case "global":
       return [globalPath];
@@ -7854,7 +8004,7 @@ var init_update_flow = __esm({
 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 fs35 from "fs";
-import * as path34 from "path";
+import * as path35 from "path";
 import { parse as parse2 } from "yaml";
 
 // src/lib/git.ts
@@ -8632,14 +8782,14 @@ init_utils();
 import { confirm as confirm8, spinner as spinner5, note as note9, outro as outro5, cancel as cancel5, isCancel as isCancel10 } from "@clack/prompts";
 import pc11 from "picocolors";
 import * as fs33 from "fs";
-import * as path33 from "path";
+import * as path34 from "path";
 async function runSyncToGlobalFlow(workspacePath, workspaceName) {
   const localPath = getLocalWorkspacePath(workspacePath);
   const customGlobalPath = getEffectiveRRCEHome(workspacePath);
-  const globalPath = path33.join(customGlobalPath, "workspaces", workspaceName);
+  const globalPath = path34.join(customGlobalPath, "workspaces", workspaceName);
   const subdirs = ["knowledge", "prompts", "templates", "tasks", "refs"];
   const existingDirs = subdirs.filter(
-    (dir) => fs33.existsSync(path33.join(localPath, dir))
+    (dir) => fs33.existsSync(path34.join(localPath, dir))
   );
   if (existingDirs.length === 0) {
     outro5(pc11.yellow("No data found in workspace storage to sync."));
@@ -8665,8 +8815,8 @@ Destination: ${pc11.cyan(globalPath)}`,
   try {
     ensureDir(globalPath);
     for (const dir of existingDirs) {
-      const srcDir = path33.join(localPath, dir);
-      const destDir = path33.join(globalPath, dir);
+      const srcDir = path34.join(localPath, dir);
+      const destDir = path34.join(globalPath, dir);
       ensureDir(destDir);
       copyDirRecursive(srcDir, destDir);
     }
@@ -8761,7 +8911,7 @@ init_config();
 function getPackageVersion3() {
   try {
     const agentCoreDir = getAgentCoreDir();
-    const packageJsonPath = path34.join(path34.dirname(agentCoreDir), "package.json");
+    const packageJsonPath = path35.join(path35.dirname(agentCoreDir), "package.json");
     if (fs35.existsSync(packageJsonPath)) {
       return JSON.parse(fs35.readFileSync(packageJsonPath, "utf8")).version;
     }
@@ -8782,7 +8932,7 @@ function getLastSyncedVersion(workspacePath, workspaceName) {
     }
   }
   const rrceHome = getEffectiveRRCEHome(workspacePath) || getDefaultRRCEHome2();
-  const mcpPath = path34.join(rrceHome, "mcp.yaml");
+  const mcpPath = path35.join(rrceHome, "mcp.yaml");
   if (fs35.existsSync(mcpPath)) {
     try {
       const content = fs35.readFileSync(mcpPath, "utf-8");
@@ -8982,12 +9132,12 @@ Workspace: ${pc13.bold(workspaceName)}`,
 init_mcp();
 var command = process.argv[2];
 var subcommand = process.argv[3];
-if (!command || command === "wizard") {
+if (!command || command === "wizard" || command === "install") {
   runWizard();
 } else if (command === "mcp") {
   runMCP(subcommand);
 } else {
   console.error(`Unknown command: ${command}`);
-  console.error("Usage: rrce-workflow [wizard|mcp]");
+  console.error("Usage: rrce-workflow [wizard|install|mcp]");
   process.exit(1);
 }

package/package.json

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