rrce-workflow 0.2.17 → 0.2.18

package/dist/index.js

@@ -1,7 +1,7 @@
 // src/commands/wizard/index.ts
-import { intro, select as select2, spinner as spinner5, note as note5, outro as outro5, isCancel as isCancel6 } from "@clack/prompts";
-import pc6 from "picocolors";
-import * as fs11 from "fs";
+import { intro, select as select2, spinner as spinner5, note as note5, outro as outro5, isCancel as isCancel5 } from "@clack/prompts";
+import pc5 from "picocolors";
+import * as fs10 from "fs";
 
 // src/lib/git.ts
 import { execSync } from "child_process";
@@ -249,10 +249,10 @@ function parseWorkspaceConfig(configPath) {
 }
 
 // src/commands/wizard/setup-flow.ts
-import { group, select, multiselect, confirm, spinner, note, outro, cancel, isCancel as isCancel2 } from "@clack/prompts";
-import pc2 from "picocolors";
-import * as fs7 from "fs";
-import * as path7 from "path";
+import { group, text, select, multiselect, confirm, spinner, note, outro, cancel, isCancel } from "@clack/prompts";
+import pc from "picocolors";
+import * as fs6 from "fs";
+import * as path6 from "path";
 
 // src/lib/prompts.ts
 import * as fs3 from "fs";
@@ -433,134 +433,6 @@ function generateVSCodeWorkspace(workspacePath, workspaceName, linkedProjects, c
   fs5.writeFileSync(workspaceFilePath, JSON.stringify(workspace, null, 2));
 }
 
-// src/lib/autocomplete-prompt.ts
-import { TextPrompt, isCancel } from "@clack/core";
-import * as fs6 from "fs";
-import * as path6 from "path";
-import pc from "picocolors";
-async function directoryAutocomplete(opts) {
-  let completions = [];
-  let completionIndex = 0;
-  let lastTabValue = "";
-  const prompt = new TextPrompt({
-    initialValue: opts.initialValue,
-    validate: opts.validate,
-    render() {
-      const title = `${pc.cyan("\u25C6")}  ${opts.message}`;
-      const hintText = opts.hint ? pc.dim(` (${opts.hint})`) : "";
-      let inputLine;
-      if (this.state === "error") {
-        inputLine = `${pc.yellow("\u25B2")}  ${this.valueWithCursor}`;
-      } else if (this.state === "submit") {
-        inputLine = `${pc.green("\u2713")}  ${pc.dim(String(this.value || ""))}`;
-      } else {
-        inputLine = `${pc.cyan("\u2502")}  ${this.valueWithCursor || pc.dim(opts.placeholder || "")}`;
-      }
-      let result2 = `${title}${hintText}
-${inputLine}`;
-      if (this.state === "error" && this.error) {
-        result2 += `
-${pc.yellow("\u2502")}  ${pc.yellow(this.error)}`;
-      }
-      if (completions.length > 1 && this.state === "active") {
-        const remaining = completions.length - 1;
-        result2 += `
-${pc.dim("\u2502")}  ${pc.dim(`+${remaining} more, press Tab again to cycle`)}`;
-      }
-      return result2;
-    }
-  });
-  prompt.on("key", (key) => {
-    if (key === "	" || key === "tab") {
-      handleTabCompletion(prompt);
-    } else {
-      completions = [];
-      completionIndex = 0;
-      lastTabValue = "";
-    }
-  });
-  function handleTabCompletion(p) {
-    const input = String(p.value || "");
-    const expanded = input.startsWith("~") ? input.replace(/^~/, process.env.HOME || "") : input;
-    if (lastTabValue === input && completions.length > 1) {
-      completionIndex = (completionIndex + 1) % completions.length;
-      const completion = completions[completionIndex] || "";
-      setPromptValue(p, completion);
-      return;
-    }
-    completions = getDirectoryCompletions(expanded);
-    completionIndex = 0;
-    lastTabValue = input;
-    if (completions.length === 1) {
-      const completion = completions[0] || "";
-      setPromptValue(p, completion.endsWith("/") ? completion : completion + "/");
-      completions = [];
-      lastTabValue = "";
-    } else if (completions.length > 1) {
-      const commonPrefix = getCommonPrefix(completions);
-      if (commonPrefix.length > expanded.length) {
-        setPromptValue(p, commonPrefix);
-        lastTabValue = formatForDisplay(commonPrefix);
-      } else {
-        setPromptValue(p, completions[0] || "");
-      }
-    }
-  }
-  function setPromptValue(p, value2) {
-    const displayValue = formatForDisplay(value2);
-    p.value = displayValue;
-  }
-  function formatForDisplay(value2) {
-    const home = process.env.HOME || "";
-    return value2.startsWith(home) ? value2.replace(home, "~") : value2;
-  }
-  function getDirectoryCompletions(inputPath) {
-    try {
-      let dirToScan;
-      let prefix;
-      if (inputPath === "" || inputPath === "/") {
-        dirToScan = inputPath || "/";
-        prefix = "";
-      } else if (inputPath.endsWith("/")) {
-        dirToScan = inputPath;
-        prefix = "";
-      } else {
-        dirToScan = path6.dirname(inputPath);
-        prefix = path6.basename(inputPath).toLowerCase();
-      }
-      if (!fs6.existsSync(dirToScan)) {
-        return [];
-      }
-      const entries = fs6.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) => path6.join(dirToScan, entry.name)).sort();
-      return entries;
-    } catch {
-      return [];
-    }
-  }
-  function getCommonPrefix(strings) {
-    if (strings.length === 0) return "";
-    if (strings.length === 1) return strings[0] || "";
-    let prefix = strings[0] || "";
-    for (let i = 1; i < strings.length; i++) {
-      const str = strings[i] || "";
-      while (prefix.length > 0 && !str.startsWith(prefix)) {
-        prefix = prefix.slice(0, -1);
-      }
-    }
-    return prefix;
-  }
-  const result = await prompt.prompt();
-  if (isCancel(result)) {
-    return result;
-  }
-  const value = String(result || "");
-  return value.startsWith("~") ? value.replace(/^~/, process.env.HOME || "") : value;
-}
-
 // src/commands/wizard/setup-flow.ts
 async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
   const s = spinner();
@@ -592,8 +464,8 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
           options: existingProjects.map((project) => ({
             value: `${project.name}:${project.source}`,
             // Unique key
-            label: `${project.name} ${pc2.dim(`(${project.source})`)}`,
-            hint: pc2.dim(
+            label: `${project.name} ${pc.dim(`(${project.source})`)}`,
+            hint: pc.dim(
               project.source === "global" ? `~/.rrce-workflow/workspaces/${project.name}` : project.dataPath
             )
           })),
@@ -643,7 +515,7 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
       `Storage: ${config.storageMode === "both" ? "global + workspace" : config.storageMode}`
     ];
     if (customGlobalPath && customGlobalPath !== getDefaultRRCEHome()) {
-      summary.push(`Global path: ${pc2.cyan(customGlobalPath)}`);
+      summary.push(`Global path: ${pc.cyan(customGlobalPath)}`);
     }
     if (dataPaths.length > 0) {
       summary.push(`Data paths:`);
@@ -656,13 +528,13 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
     const linkedProjects = config.linkedProjects;
     if (linkedProjects.length > 0) {
       summary.push(`Linked projects: ${linkedProjects.join(", ")}`);
-      summary.push(`Workspace file: ${pc2.cyan(`${workspaceName}.code-workspace`)}`);
+      summary.push(`Workspace file: ${pc.cyan(`${workspaceName}.code-workspace`)}`);
     }
     note(summary.join("\n"), "Setup Summary");
     if (linkedProjects.length > 0) {
-      outro(pc2.green(`\u2713 Setup complete! Open ${pc2.bold(`${workspaceName}.code-workspace`)} in VSCode to access linked knowledge.`));
+      outro(pc.green(`\u2713 Setup complete! Open ${pc.bold(`${workspaceName}.code-workspace`)} in VSCode to access linked knowledge.`));
     } else {
-      outro(pc2.green(`\u2713 Setup complete! Your agents are ready to use.`));
+      outro(pc.green(`\u2713 Setup complete! Your agents are ready to use.`));
     }
   } catch (error) {
     s.stop("Error occurred");
@@ -677,7 +549,7 @@ async function resolveGlobalPath() {
   options.push({
     value: "default",
     label: `Default (${defaultPath})`,
-    hint: isDefaultWritable ? pc2.green("\u2713 writable") : pc2.red("\u2717 not writable")
+    hint: isDefaultWritable ? pc.green("\u2713 writable") : pc.red("\u2717 not writable")
   });
   options.push({
     value: "custom",
@@ -689,14 +561,14 @@ async function resolveGlobalPath() {
     options,
     initialValue: isDefaultWritable ? "default" : "custom"
   });
-  if (isCancel2(choice)) {
+  if (isCancel(choice)) {
     return void 0;
   }
   if (choice === "default") {
     if (!isDefaultWritable) {
       note(
-        `${pc2.yellow("\u26A0")} Cannot write to default path:
-  ${pc2.dim(defaultPath)}
+        `${pc.yellow("\u26A0")} Cannot write to default path:
+  ${pc.dim(defaultPath)}
 
 This can happen when running via npx/bunx in restricted environments.
 Please choose a custom path instead.`,
@@ -706,18 +578,18 @@ Please choose a custom path instead.`,
     }
     return defaultPath;
   }
-  const suggestedPath = path7.join(process.env.HOME || "~", ".local", "share", "rrce-workflow");
-  const customPath = await directoryAutocomplete({
+  const suggestedPath = path6.join(process.env.HOME || "~", ".local", "share", "rrce-workflow");
+  const customPath = await text({
     message: "Enter custom global path:",
-    initialValue: suggestedPath,
-    hint: "Tab to autocomplete",
+    defaultValue: suggestedPath,
+    placeholder: suggestedPath,
     validate: (value) => {
       if (!value.trim()) {
         return "Path cannot be empty";
       }
-      const expandedPath = value.startsWith("~") ? value.replace("~", process.env.HOME || "") : value;
-      if (!checkWriteAccess(expandedPath)) {
-        return `Cannot write to ${expandedPath}. Please choose a writable path.`;
+      const expandedPath2 = value.startsWith("~") ? value.replace("~", process.env.HOME || "") : value;
+      if (!checkWriteAccess(expandedPath2)) {
+        return `Cannot write to ${expandedPath2}. Please choose a writable path.`;
       }
       return void 0;
     }
@@ -725,20 +597,24 @@ Please choose a custom path instead.`,
   if (isCancel(customPath)) {
     return void 0;
   }
-  return customPath;
+  let expandedPath = customPath.startsWith("~") ? customPath.replace("~", process.env.HOME || "") : customPath;
+  if (!expandedPath.endsWith(".rrce-workflow")) {
+    expandedPath = path6.join(expandedPath, ".rrce-workflow");
+  }
+  return expandedPath;
 }
 async function generateConfiguration(config, workspacePath, workspaceName, allProjects = []) {
   const dataPaths = getDataPaths(config.storageMode, workspaceName, workspacePath, config.globalPath);
   for (const dataPath of dataPaths) {
     ensureDir(dataPath);
-    ensureDir(path7.join(dataPath, "knowledge"));
-    ensureDir(path7.join(dataPath, "refs"));
-    ensureDir(path7.join(dataPath, "tasks"));
-    ensureDir(path7.join(dataPath, "templates"));
+    ensureDir(path6.join(dataPath, "knowledge"));
+    ensureDir(path6.join(dataPath, "refs"));
+    ensureDir(path6.join(dataPath, "tasks"));
+    ensureDir(path6.join(dataPath, "templates"));
   }
   const agentCoreDir = getAgentCoreDir();
   syncMetadataToAll(agentCoreDir, dataPaths);
-  copyDirToAllStoragePaths(path7.join(agentCoreDir, "templates"), "templates", dataPaths);
+  copyDirToAllStoragePaths(path6.join(agentCoreDir, "templates"), "templates", dataPaths);
   const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
   if (config.tools.includes("copilot")) {
     const copilotPath = getAgentPromptPath(workspacePath, "copilot");
@@ -750,8 +626,8 @@ async function generateConfiguration(config, workspacePath, workspaceName, allPr
     ensureDir(antigravityPath);
     copyPromptsToDir(prompts, antigravityPath, ".md");
   }
-  const workspaceConfigPath = path7.join(workspacePath, ".rrce-workflow", "config.yaml");
-  ensureDir(path7.dirname(workspaceConfigPath));
+  const workspaceConfigPath = path6.join(workspacePath, ".rrce-workflow", "config.yaml");
+  ensureDir(path6.dirname(workspaceConfigPath));
   let configContent = `# RRCE-Workflow Configuration
 version: 1
 
@@ -779,7 +655,7 @@ linked_projects:
 `;
     });
   }
-  fs7.writeFileSync(workspaceConfigPath, configContent);
+  fs6.writeFileSync(workspaceConfigPath, configContent);
   if (config.tools.includes("copilot") || config.linkedProjects.length > 0) {
     const selectedProjects = allProjects.filter(
       (p) => config.linkedProjects.includes(`${p.name}:${p.source}`)
@@ -788,8 +664,8 @@ linked_projects:
   }
 }
 function getDataPaths(mode, workspaceName, workspaceRoot, customGlobalPath) {
-  const globalPath = path7.join(customGlobalPath || getDefaultRRCEHome(), "workspaces", workspaceName);
-  const workspacePath = path7.join(workspaceRoot, ".rrce-workflow");
+  const globalPath = path6.join(customGlobalPath || getDefaultRRCEHome(), "workspaces", workspaceName);
+  const workspacePath = path6.join(workspaceRoot, ".rrce-workflow");
   switch (mode) {
     case "global":
       return [globalPath];
@@ -803,9 +679,9 @@ function getDataPaths(mode, workspaceName, workspaceRoot, customGlobalPath) {
 }
 
 // src/commands/wizard/link-flow.ts
-import { multiselect as multiselect2, spinner as spinner2, note as note2, outro as outro2, cancel as cancel2, isCancel as isCancel3 } from "@clack/prompts";
-import pc3 from "picocolors";
-import * as fs8 from "fs";
+import { multiselect as multiselect2, spinner as spinner2, note as note2, outro as outro2, cancel as cancel2, isCancel as isCancel2 } from "@clack/prompts";
+import pc2 from "picocolors";
+import * as fs7 from "fs";
 async function runLinkProjectsFlow(workspacePath, workspaceName) {
   const projects = scanForProjects({
     excludeWorkspace: workspaceName,
@@ -813,7 +689,7 @@ async function runLinkProjectsFlow(workspacePath, workspaceName) {
     scanSiblings: true
   });
   if (projects.length === 0) {
-    outro2(pc3.yellow("No other projects found. Try setting up another project first."));
+    outro2(pc2.yellow("No other projects found. Try setting up another project first."));
     return;
   }
   const customGlobalPath = getEffectiveRRCEHome(workspacePath);
@@ -822,14 +698,14 @@ async function runLinkProjectsFlow(workspacePath, workspaceName) {
     options: projects.map((project) => ({
       value: `${project.name}:${project.source}`,
       // Unique key
-      label: `${project.name} ${pc3.dim(`(${project.source})`)}`,
-      hint: pc3.dim(
+      label: `${project.name} ${pc2.dim(`(${project.source})`)}`,
+      hint: pc2.dim(
         project.source === "global" ? `~/.rrce-workflow/workspaces/${project.name}` : project.dataPath
       )
     })),
     required: true
   });
-  if (isCancel3(linkedProjects)) {
+  if (isCancel2(linkedProjects)) {
     cancel2("Cancelled.");
     process.exit(0);
   }
@@ -844,7 +720,7 @@ async function runLinkProjectsFlow(workspacePath, workspaceName) {
   const s = spinner2();
   s.start("Linking projects");
   const configFilePath = getConfigPath(workspacePath);
-  let configContent = fs8.readFileSync(configFilePath, "utf-8");
+  let configContent = fs7.readFileSync(configFilePath, "utf-8");
   if (configContent.includes("linked_projects:")) {
     const lines = configContent.split("\n");
     const linkedIndex = lines.findIndex((l) => l.trim() === "linked_projects:");
@@ -871,49 +747,49 @@ linked_projects:
 `;
     });
   }
-  fs8.writeFileSync(configFilePath, configContent);
+  fs7.writeFileSync(configFilePath, configContent);
   generateVSCodeWorkspace(workspacePath, workspaceName, selectedProjects, customGlobalPath);
   s.stop("Projects linked");
   const workspaceFile = `${workspaceName}.code-workspace`;
   const summary = [
     `Linked projects:`,
-    ...selectedProjects.map((p) => `  \u2713 ${p.name} ${pc3.dim(`(${p.source})`)}`),
+    ...selectedProjects.map((p) => `  \u2713 ${p.name} ${pc2.dim(`(${p.source})`)}`),
     ``,
-    `Workspace file: ${pc3.cyan(workspaceFile)}`
+    `Workspace file: ${pc2.cyan(workspaceFile)}`
   ];
   note2(summary.join("\n"), "Link Summary");
-  outro2(pc3.green(`\u2713 Projects linked! Open ${pc3.bold(workspaceFile)} in VSCode to access linked data.`));
+  outro2(pc2.green(`\u2713 Projects linked! Open ${pc2.bold(workspaceFile)} in VSCode to access linked data.`));
 }
 
 // src/commands/wizard/sync-flow.ts
-import { confirm as confirm2, spinner as spinner3, note as note3, outro as outro3, cancel as cancel3, isCancel as isCancel4 } from "@clack/prompts";
-import pc4 from "picocolors";
-import * as fs9 from "fs";
-import * as path8 from "path";
+import { confirm as confirm2, spinner as spinner3, note as note3, outro as outro3, cancel as cancel3, isCancel as isCancel3 } from "@clack/prompts";
+import pc3 from "picocolors";
+import * as fs8 from "fs";
+import * as path7 from "path";
 async function runSyncToGlobalFlow(workspacePath, workspaceName) {
   const localPath = getLocalWorkspacePath(workspacePath);
   const customGlobalPath = getEffectiveRRCEHome(workspacePath);
-  const globalPath = path8.join(customGlobalPath, "workspaces", workspaceName);
+  const globalPath = path7.join(customGlobalPath, "workspaces", workspaceName);
   const subdirs = ["knowledge", "prompts", "templates", "tasks", "refs"];
   const existingDirs = subdirs.filter(
-    (dir) => fs9.existsSync(path8.join(localPath, dir))
+    (dir) => fs8.existsSync(path7.join(localPath, dir))
   );
   if (existingDirs.length === 0) {
-    outro3(pc4.yellow("No data found in workspace storage to sync."));
+    outro3(pc3.yellow("No data found in workspace storage to sync."));
     return;
   }
   note3(
     `The following will be copied to global storage:
 ${existingDirs.map((d) => `  \u2022 ${d}/`).join("\n")}
 
-Destination: ${pc4.cyan(globalPath)}`,
+Destination: ${pc3.cyan(globalPath)}`,
     "Sync Preview"
   );
   const shouldSync = await confirm2({
     message: "Proceed with sync to global storage?",
     initialValue: true
   });
-  if (isCancel4(shouldSync) || !shouldSync) {
+  if (isCancel3(shouldSync) || !shouldSync) {
     outro3("Sync cancelled.");
     return;
   }
@@ -922,27 +798,27 @@ Destination: ${pc4.cyan(globalPath)}`,
   try {
     ensureDir(globalPath);
     for (const dir of existingDirs) {
-      const srcDir = path8.join(localPath, dir);
-      const destDir = path8.join(globalPath, dir);
+      const srcDir = path7.join(localPath, dir);
+      const destDir = path7.join(globalPath, dir);
       ensureDir(destDir);
       copyDirRecursive(srcDir, destDir);
     }
     const configFilePath = getConfigPath(workspacePath);
-    let configContent = fs9.readFileSync(configFilePath, "utf-8");
+    let configContent = fs8.readFileSync(configFilePath, "utf-8");
     configContent = configContent.replace(/mode:\s*workspace/, "mode: both");
-    fs9.writeFileSync(configFilePath, configContent);
+    fs8.writeFileSync(configFilePath, configContent);
     s.stop("Sync complete");
     const summary = [
       `Synced directories:`,
       ...existingDirs.map((d) => `  \u2713 ${d}/`),
       ``,
-      `Global path: ${pc4.cyan(globalPath)}`,
-      `Storage mode updated to: ${pc4.bold("both")}`,
+      `Global path: ${pc3.cyan(globalPath)}`,
+      `Storage mode updated to: ${pc3.bold("both")}`,
       ``,
       `Other projects can now link this knowledge!`
     ];
     note3(summary.join("\n"), "Sync Summary");
-    outro3(pc4.green("\u2713 Workspace knowledge synced to global storage!"));
+    outro3(pc3.green("\u2713 Workspace knowledge synced to global storage!"));
   } catch (error) {
     s.stop("Error occurred");
     cancel3(`Failed to sync: ${error instanceof Error ? error.message : String(error)}`);
@@ -951,10 +827,10 @@ Destination: ${pc4.cyan(globalPath)}`,
 }
 
 // src/commands/wizard/update-flow.ts
-import { confirm as confirm3, spinner as spinner4, note as note4, outro as outro4, cancel as cancel4, isCancel as isCancel5 } from "@clack/prompts";
-import pc5 from "picocolors";
-import * as fs10 from "fs";
-import * as path9 from "path";
+import { confirm as confirm3, spinner as spinner4, note as note4, outro as outro4, cancel as cancel4, isCancel as isCancel4 } from "@clack/prompts";
+import pc4 from "picocolors";
+import * as fs9 from "fs";
+import * as path8 from "path";
 async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
   const s = spinner4();
   s.start("Checking for updates");
@@ -978,16 +854,16 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
       message: "Proceed with update?",
       initialValue: true
     });
-    if (isCancel5(shouldUpdate) || !shouldUpdate) {
+    if (isCancel4(shouldUpdate) || !shouldUpdate) {
       outro4("Update cancelled.");
       return;
     }
     s.start("Updating from package");
     for (const dataPath of dataPaths) {
-      copyDirToAllStoragePaths(path9.join(agentCoreDir, "templates"), "templates", [dataPath]);
+      copyDirToAllStoragePaths(path8.join(agentCoreDir, "templates"), "templates", [dataPath]);
     }
     const configFilePath = getConfigPath(workspacePath);
-    const configContent = fs10.readFileSync(configFilePath, "utf-8");
+    const configContent = fs9.readFileSync(configFilePath, "utf-8");
     if (configContent.includes("copilot: true")) {
       const copilotPath = getAgentPromptPath(workspacePath, "copilot");
       ensureDir(copilotPath);
@@ -1007,7 +883,7 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
       `Your configuration and knowledge files were preserved.`
     ];
     note4(summary.join("\n"), "Update Summary");
-    outro4(pc5.green("\u2713 Successfully updated from package!"));
+    outro4(pc4.green("\u2713 Successfully updated from package!"));
   } catch (error) {
     s.stop("Error occurred");
     cancel4(`Failed to update: ${error instanceof Error ? error.message : String(error)}`);
@@ -1015,8 +891,8 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
   }
 }
 function resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspaceRoot, customGlobalPath) {
-  const globalPath = path9.join(customGlobalPath, "workspaces", workspaceName);
-  const workspacePath = path9.join(workspaceRoot, ".rrce-workflow");
+  const globalPath = path8.join(customGlobalPath, "workspaces", workspaceName);
+  const workspacePath = path8.join(workspaceRoot, ".rrce-workflow");
   switch (mode) {
     case "global":
       return [globalPath];
@@ -1031,7 +907,7 @@ function resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspaceRoot,
 
 // src/commands/wizard/index.ts
 async function runWizard() {
-  intro(pc6.cyan(pc6.inverse(" RRCE-Workflow Setup ")));
+  intro(pc5.cyan(pc5.inverse(" RRCE-Workflow Setup ")));
   const s = spinner5();
   s.start("Detecting environment");
   const workspacePath = detectWorkspaceRoot();
@@ -1040,8 +916,8 @@ async function runWizard() {
   await new Promise((r) => setTimeout(r, 800));
   s.stop("Environment detected");
   note5(
-    `Git User:  ${pc6.bold(gitUser || "(not found)")}
-Workspace: ${pc6.bold(workspaceName)}`,
+    `Git User:  ${pc5.bold(gitUser || "(not found)")}
+Workspace: ${pc5.bold(workspaceName)}`,
     "Context"
   );
   const detectedProjects = scanForProjects({
@@ -1050,18 +926,18 @@ Workspace: ${pc6.bold(workspaceName)}`,
     scanSiblings: true
   });
   const configFilePath = getConfigPath(workspacePath);
-  const isAlreadyConfigured = fs11.existsSync(configFilePath);
+  const isAlreadyConfigured = fs10.existsSync(configFilePath);
   let currentStorageMode = null;
   if (isAlreadyConfigured) {
     try {
-      const configContent = fs11.readFileSync(configFilePath, "utf-8");
+      const configContent = fs10.readFileSync(configFilePath, "utf-8");
       const modeMatch = configContent.match(/mode:\s*(global|workspace|both)/);
       currentStorageMode = modeMatch?.[1] ?? null;
     } catch {
     }
   }
   const localDataPath = getLocalWorkspacePath(workspacePath);
-  const hasLocalData = fs11.existsSync(localDataPath);
+  const hasLocalData = fs10.existsSync(localDataPath);
   if (isAlreadyConfigured) {
     const menuOptions = [];
     if (detectedProjects.length > 0) {
@@ -1084,7 +960,7 @@ Workspace: ${pc6.bold(workspaceName)}`,
       message: "This workspace is already configured. What would you like to do?",
       options: menuOptions
     });
-    if (isCancel6(action) || action === "exit") {
+    if (isCancel5(action) || action === "exit") {
       outro5("Exited.");
       process.exit(0);
     }
@@ -1105,12 +981,12 @@ Workspace: ${pc6.bold(workspaceName)}`,
 }
 
 // src/commands/selector.ts
-import { intro as intro2, select as select3, note as note6, cancel as cancel6, isCancel as isCancel7, outro as outro6 } from "@clack/prompts";
-import pc7 from "picocolors";
-import * as path10 from "path";
+import { intro as intro2, select as select3, note as note6, cancel as cancel6, isCancel as isCancel6, outro as outro6 } from "@clack/prompts";
+import pc6 from "picocolors";
+import * as path9 from "path";
 async function runSelector() {
-  const workspaceName = path10.basename(process.cwd());
-  intro2(pc7.cyan(pc7.inverse(` RRCE-Workflow | ${workspaceName} `)));
+  const workspaceName = path9.basename(process.cwd());
+  intro2(pc6.cyan(pc6.inverse(` RRCE-Workflow | ${workspaceName} `)));
   const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
   if (prompts.length === 0) {
     cancel6("No agents found. Run `rrce-workflow` to set up.");
@@ -1124,14 +1000,14 @@ async function runSelector() {
       hint: p.frontmatter.description
     }))
   });
-  if (isCancel7(selection)) {
+  if (isCancel6(selection)) {
     cancel6("Selection cancelled.");
     process.exit(0);
   }
   const prompt = selection;
   note6(
     `Use this agent in your IDE by invoking:
-${pc7.bold(pc7.cyan(`@${prompt.frontmatter.name}`))}`,
+${pc6.bold(pc6.cyan(`@${prompt.frontmatter.name}`))}`,
     "Agent Selected"
   );
   outro6("Done");

package/package.json

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