rrce-workflow 0.2.15 → 0.2.16

package/dist/index.js

@@ -49,18 +49,6 @@ function getWorkspaceName(workspaceRoot) {
 function getRRCEHome() {
   return RRCE_HOME;
 }
-function listGlobalProjects(excludeWorkspace) {
-  const workspacesDir = path.join(RRCE_HOME, "workspaces");
-  if (!fs.existsSync(workspacesDir)) {
-    return [];
-  }
-  try {
-    const entries = fs.readdirSync(workspacesDir, { withFileTypes: true });
-    return entries.filter((entry) => entry.isDirectory() && entry.name !== excludeWorkspace).map((entry) => entry.name);
-  } catch {
-    return [];
-  }
-}
 function getLocalWorkspacePath(workspaceRoot) {
   return path.join(workspaceRoot, ".rrce-workflow");
 }
@@ -145,115 +133,9 @@ function getEffectiveRRCEHome(workspaceRoot) {
   return getDefaultRRCEHome();
 }
 
-// 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";
-
-// src/lib/prompts.ts
+// src/lib/detection.ts
 import * as fs2 from "fs";
 import * as path2 from "path";
-import { fileURLToPath } from "url";
-import matter from "gray-matter";
-
-// src/types/prompt.ts
-import { z } from "zod";
-var PromptArgSchema = z.object({
-  name: z.string(),
-  default: z.string().optional(),
-  prompt: z.string().optional()
-});
-var AutoIdentitySchema = z.object({
-  user: z.string(),
-  model: z.string()
-});
-var 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(),
-  "required-args": z.array(PromptArgSchema).optional(),
-  "optional-args": z.array(PromptArgSchema).optional(),
-  "auto-identity": AutoIdentitySchema.optional()
-});
-
-// src/lib/prompts.ts
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = path2.dirname(__filename);
-function parsePromptFile(filePath) {
-  try {
-    const fileContent = fs2.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 (!fs2.existsSync(dirPath)) {
-    return [];
-  }
-  const files = fs2.readdirSync(dirPath).filter((f) => f.endsWith(".md"));
-  const prompts = [];
-  for (const file of files) {
-    const prompt = parsePromptFile(path2.join(dirPath, file));
-    if (prompt) {
-      prompts.push(prompt);
-    }
-  }
-  return prompts;
-}
-function getAgentCoreDir() {
-  return path2.join(__dirname, "..", "..", "agent-core");
-}
-function getAgentCorePromptsDir() {
-  return path2.join(getAgentCoreDir(), "prompts");
-}
-
-// src/commands/wizard/utils.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
-function copyPromptsToDir(prompts, targetDir, extension) {
-  for (const prompt of prompts) {
-    const baseName = path3.basename(prompt.filePath, ".md");
-    const targetName = baseName + extension;
-    const targetPath = path3.join(targetDir, targetName);
-    const content = fs3.readFileSync(prompt.filePath, "utf-8");
-    fs3.writeFileSync(targetPath, content);
-  }
-}
-function copyDirRecursive(src, dest) {
-  const entries = fs3.readdirSync(src, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = path3.join(src, entry.name);
-    const destPath = path3.join(dest, entry.name);
-    if (entry.isDirectory()) {
-      ensureDir(destPath);
-      copyDirRecursive(srcPath, destPath);
-    } else {
-      fs3.copyFileSync(srcPath, destPath);
-    }
-  }
-}
-
-// src/commands/wizard/vscode.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
-
-// src/lib/detection.ts
-import * as fs4 from "fs";
-import * as path4 from "path";
 function scanForProjects(options = {}) {
   const { excludeWorkspace, workspacePath, scanSiblings = true } = options;
   const projects = [];
@@ -278,29 +160,29 @@ function scanForProjects(options = {}) {
 }
 function scanGlobalStorage(excludeWorkspace) {
   const rrceHome = getDefaultRRCEHome();
-  const workspacesDir = path4.join(rrceHome, "workspaces");
+  const workspacesDir = path2.join(rrceHome, "workspaces");
   const projects = [];
-  if (!fs4.existsSync(workspacesDir)) {
+  if (!fs2.existsSync(workspacesDir)) {
     return projects;
   }
   try {
-    const entries = fs4.readdirSync(workspacesDir, { withFileTypes: true });
+    const entries = fs2.readdirSync(workspacesDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       if (entry.name === excludeWorkspace) continue;
-      const projectDataPath = path4.join(workspacesDir, entry.name);
-      const knowledgePath = path4.join(projectDataPath, "knowledge");
-      const refsPath = path4.join(projectDataPath, "refs");
-      const tasksPath = path4.join(projectDataPath, "tasks");
+      const projectDataPath = path2.join(workspacesDir, entry.name);
+      const knowledgePath = path2.join(projectDataPath, "knowledge");
+      const refsPath = path2.join(projectDataPath, "refs");
+      const tasksPath = path2.join(projectDataPath, "tasks");
       projects.push({
         name: entry.name,
         path: projectDataPath,
         // For global projects, path is the data path
         dataPath: projectDataPath,
         source: "global",
-        knowledgePath: fs4.existsSync(knowledgePath) ? knowledgePath : void 0,
-        refsPath: fs4.existsSync(refsPath) ? refsPath : void 0,
-        tasksPath: fs4.existsSync(tasksPath) ? tasksPath : void 0
+        knowledgePath: fs2.existsSync(knowledgePath) ? knowledgePath : void 0,
+        refsPath: fs2.existsSync(refsPath) ? refsPath : void 0,
+        tasksPath: fs2.existsSync(tasksPath) ? tasksPath : void 0
       });
     }
   } catch {
@@ -308,32 +190,32 @@ function scanGlobalStorage(excludeWorkspace) {
   return projects;
 }
 function scanSiblingDirectories(workspacePath, excludeWorkspace) {
-  const parentDir = path4.dirname(workspacePath);
+  const parentDir = path2.dirname(workspacePath);
   const projects = [];
   try {
-    const entries = fs4.readdirSync(parentDir, { withFileTypes: true });
+    const entries = fs2.readdirSync(parentDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const projectPath = path4.join(parentDir, entry.name);
+      const projectPath = path2.join(parentDir, entry.name);
       if (projectPath === workspacePath) continue;
       if (entry.name === excludeWorkspace) continue;
-      const configPath = path4.join(projectPath, ".rrce-workflow", "config.yaml");
-      if (!fs4.existsSync(configPath)) continue;
+      const configPath = path2.join(projectPath, ".rrce-workflow", "config.yaml");
+      if (!fs2.existsSync(configPath)) continue;
       const config = parseWorkspaceConfig(configPath);
       if (!config) continue;
-      const dataPath = path4.join(projectPath, ".rrce-workflow");
-      const knowledgePath = path4.join(dataPath, "knowledge");
-      const refsPath = path4.join(dataPath, "refs");
-      const tasksPath = path4.join(dataPath, "tasks");
+      const dataPath = path2.join(projectPath, ".rrce-workflow");
+      const knowledgePath = path2.join(dataPath, "knowledge");
+      const refsPath = path2.join(dataPath, "refs");
+      const tasksPath = path2.join(dataPath, "tasks");
       projects.push({
         name: config.name || entry.name,
         path: projectPath,
         dataPath,
         source: "sibling",
         storageMode: config.storageMode,
-        knowledgePath: fs4.existsSync(knowledgePath) ? knowledgePath : void 0,
-        refsPath: fs4.existsSync(refsPath) ? refsPath : void 0,
-        tasksPath: fs4.existsSync(tasksPath) ? tasksPath : void 0
+        knowledgePath: fs2.existsSync(knowledgePath) ? knowledgePath : void 0,
+        refsPath: fs2.existsSync(refsPath) ? refsPath : void 0,
+        tasksPath: fs2.existsSync(tasksPath) ? tasksPath : void 0
       });
     }
   } catch {
@@ -342,7 +224,7 @@ function scanSiblingDirectories(workspacePath, excludeWorkspace) {
 }
 function parseWorkspaceConfig(configPath) {
   try {
-    const content = fs4.readFileSync(configPath, "utf-8");
+    const content = fs2.readFileSync(configPath, "utf-8");
     const nameMatch = content.match(/name:\s*["']?([^"'\n]+)["']?/);
     const modeMatch = content.match(/mode:\s*(global|workspace|both)/);
     const linkedProjects = [];
@@ -357,7 +239,7 @@ function parseWorkspaceConfig(configPath) {
       }
     }
     return {
-      name: nameMatch?.[1]?.trim() || path4.basename(path4.dirname(path4.dirname(configPath))),
+      name: nameMatch?.[1]?.trim() || path2.basename(path2.dirname(path2.dirname(configPath))),
       storageMode: modeMatch?.[1] || "global",
       linkedProjects: linkedProjects.length > 0 ? linkedProjects : void 0
     };
@@ -401,7 +283,111 @@ function getProjectFolders(project) {
   return folders;
 }
 
+// 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";
+
+// src/lib/prompts.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import { fileURLToPath } from "url";
+import matter from "gray-matter";
+
+// src/types/prompt.ts
+import { z } from "zod";
+var PromptArgSchema = z.object({
+  name: z.string(),
+  default: z.string().optional(),
+  prompt: z.string().optional()
+});
+var AutoIdentitySchema = z.object({
+  user: z.string(),
+  model: z.string()
+});
+var 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(),
+  "required-args": z.array(PromptArgSchema).optional(),
+  "optional-args": z.array(PromptArgSchema).optional(),
+  "auto-identity": AutoIdentitySchema.optional()
+});
+
+// src/lib/prompts.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path3.dirname(__filename);
+function parsePromptFile(filePath) {
+  try {
+    const fileContent = fs3.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 (!fs3.existsSync(dirPath)) {
+    return [];
+  }
+  const files = fs3.readdirSync(dirPath).filter((f) => f.endsWith(".md"));
+  const prompts = [];
+  for (const file of files) {
+    const prompt = parsePromptFile(path3.join(dirPath, file));
+    if (prompt) {
+      prompts.push(prompt);
+    }
+  }
+  return prompts;
+}
+function getAgentCoreDir() {
+  return path3.join(__dirname, "..", "..", "agent-core");
+}
+function getAgentCorePromptsDir() {
+  return path3.join(getAgentCoreDir(), "prompts");
+}
+
+// src/commands/wizard/utils.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+function copyPromptsToDir(prompts, targetDir, extension) {
+  for (const prompt of prompts) {
+    const baseName = path4.basename(prompt.filePath, ".md");
+    const targetName = baseName + extension;
+    const targetPath = path4.join(targetDir, targetName);
+    const content = fs4.readFileSync(prompt.filePath, "utf-8");
+    fs4.writeFileSync(targetPath, content);
+  }
+}
+function copyDirRecursive(src, dest) {
+  const entries = fs4.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path4.join(src, entry.name);
+    const destPath = path4.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      ensureDir(destPath);
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      fs4.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
 // src/commands/wizard/vscode.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
 var REFERENCE_GROUP_PREFIX = "\u{1F4C1} References";
 function generateVSCodeWorkspace(workspacePath, workspaceName, linkedProjects, customGlobalPath) {
   const workspaceFilePath = path5.join(workspacePath, `${workspaceName}.code-workspace`);
@@ -647,10 +633,10 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
         }
         return multiselect({
           message: "Link knowledge from other projects?",
-          options: existingProjects.map((name) => ({
-            value: name,
-            label: name,
-            hint: `~/.rrce-workflow/workspaces/${name}/knowledge`
+          options: existingProjects.map((project) => ({
+            value: project.name,
+            label: project.name,
+            hint: pc2.dim(getProjectDisplayLabel(project))
           })),
           required: false
         });
@@ -686,7 +672,7 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
       globalPath: customGlobalPath,
       tools: config.tools,
       linkedProjects: config.linkedProjects
-    }, workspacePath, workspaceName);
+    }, workspacePath, workspaceName, existingProjects);
     s.stop("Configuration generated");
     const dataPaths = getDataPaths(
       config.storageMode,
@@ -782,7 +768,7 @@ Please choose a custom path instead.`,
   }
   return customPath;
 }
-async function generateConfiguration(config, workspacePath, workspaceName) {
+async function generateConfiguration(config, workspacePath, workspaceName, allProjects = []) {
   const dataPaths = getDataPaths(config.storageMode, workspaceName, workspacePath, config.globalPath);
   for (const dataPath of dataPaths) {
     ensureDir(dataPath);
@@ -836,7 +822,8 @@ linked_projects:
   }
   fs7.writeFileSync(workspaceConfigPath, configContent);
   if (config.tools.includes("copilot") || config.linkedProjects.length > 0) {
-    generateVSCodeWorkspace(workspacePath, workspaceName, config.linkedProjects, config.globalPath);
+    const selectedProjects = allProjects.filter((p) => config.linkedProjects.includes(p.name));
+    generateVSCodeWorkspace(workspacePath, workspaceName, selectedProjects, config.globalPath);
   }
 }
 function getDataPaths(mode, workspaceName, workspaceRoot, customGlobalPath) {
@@ -858,13 +845,12 @@ function getDataPaths(mode, workspaceName, workspaceRoot, customGlobalPath) {
 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";
-async function runLinkProjectsFlow(workspacePath, workspaceName, existingProjects) {
-  const detectedProjects = scanForProjects({
+async function runLinkProjectsFlow(workspacePath, workspaceName) {
+  const projects = scanForProjects({
     excludeWorkspace: workspaceName,
     workspacePath,
     scanSiblings: true
   });
-  const projects = existingProjects ? existingProjects.map((name) => ({ name, source: "global" })) : detectedProjects;
   if (projects.length === 0) {
     outro2(pc3.yellow("No other projects found. Try setting up another project first."));
     return;
@@ -1093,7 +1079,11 @@ async function runWizard() {
 Workspace: ${pc6.bold(workspaceName)}`,
     "Context"
   );
-  const existingProjects = listGlobalProjects(workspaceName);
+  const detectedProjects = scanForProjects({
+    excludeWorkspace: workspaceName,
+    workspacePath,
+    scanSiblings: true
+  });
   const configFilePath = getConfigPath(workspacePath);
   const isAlreadyConfigured = fs11.existsSync(configFilePath);
   let currentStorageMode = null;
@@ -1109,11 +1099,11 @@ Workspace: ${pc6.bold(workspaceName)}`,
   const hasLocalData = fs11.existsSync(localDataPath);
   if (isAlreadyConfigured) {
     const menuOptions = [];
-    if (existingProjects.length > 0) {
+    if (detectedProjects.length > 0) {
       menuOptions.push({
         value: "link",
         label: "Link other project knowledge",
-        hint: `${existingProjects.length} projects available`
+        hint: `${detectedProjects.length} projects detected (global + sibling)`
       });
     }
     if (currentStorageMode === "workspace" && hasLocalData) {
@@ -1134,7 +1124,7 @@ Workspace: ${pc6.bold(workspaceName)}`,
       process.exit(0);
     }
     if (action === "link") {
-      await runLinkProjectsFlow(workspacePath, workspaceName, existingProjects);
+      await runLinkProjectsFlow(workspacePath, workspaceName);
       return;
     }
     if (action === "sync-global") {
@@ -1146,7 +1136,7 @@ Workspace: ${pc6.bold(workspaceName)}`,
       return;
     }
   }
-  await runSetupFlow(workspacePath, workspaceName, existingProjects);
+  await runSetupFlow(workspacePath, workspaceName, detectedProjects);
 }
 
 // src/commands/selector.ts

package/package.json

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