rrce-workflow 0.2.14 → 0.2.16

package/dist/index.js

@@ -0,0 +1,1181 @@
+// 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";
+
+// src/lib/git.ts
+import { execSync } from "child_process";
+function getGitUser() {
+  try {
+    const result = execSync("git config user.name", { encoding: "utf-8" });
+    return result.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+// src/lib/paths.ts
+import * as fs from "fs";
+import * as path from "path";
+var RRCE_HOME = process.env.RRCE_HOME || path.join(process.env.HOME || "~", ".rrce-workflow");
+var RRCE_WORKSPACE = process.env.RRCE_WORKSPACE;
+function detectWorkspaceRoot() {
+  if (RRCE_WORKSPACE) {
+    return RRCE_WORKSPACE;
+  }
+  let current = process.cwd();
+  while (current !== "/") {
+    if (fs.existsSync(path.join(current, ".git")) || fs.existsSync(path.join(current, ".rrce-workflow", "config.yaml")) || fs.existsSync(path.join(current, ".rrce-workflow.yaml"))) {
+      return current;
+    }
+    current = path.dirname(current);
+  }
+  return process.cwd();
+}
+function getConfigPath(workspaceRoot) {
+  const newPath = path.join(workspaceRoot, ".rrce-workflow", "config.yaml");
+  const legacyPath = path.join(workspaceRoot, ".rrce-workflow.yaml");
+  if (fs.existsSync(newPath)) {
+    return newPath;
+  }
+  if (fs.existsSync(legacyPath)) {
+    return legacyPath;
+  }
+  return newPath;
+}
+function getWorkspaceName(workspaceRoot) {
+  return path.basename(workspaceRoot);
+}
+function getRRCEHome() {
+  return RRCE_HOME;
+}
+function getLocalWorkspacePath(workspaceRoot) {
+  return path.join(workspaceRoot, ".rrce-workflow");
+}
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+function getAgentPromptPath(workspaceRoot, tool) {
+  if (tool === "copilot") {
+    return path.join(workspaceRoot, ".github", "agents");
+  } else {
+    return path.join(workspaceRoot, ".agent", "workflows");
+  }
+}
+function copyToAllStoragePaths(sourceFile, relativePath, dataPaths) {
+  const content = fs.readFileSync(sourceFile);
+  for (const dataPath of dataPaths) {
+    const targetPath = path.join(dataPath, relativePath);
+    ensureDir(path.dirname(targetPath));
+    fs.writeFileSync(targetPath, content);
+  }
+}
+function copyDirToAllStoragePaths(sourceDir, relativeDir, dataPaths) {
+  if (!fs.existsSync(sourceDir)) {
+    return;
+  }
+  const entries = fs.readdirSync(sourceDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const sourcePath = path.join(sourceDir, entry.name);
+    const relativePath = path.join(relativeDir, entry.name);
+    if (entry.isDirectory()) {
+      copyDirToAllStoragePaths(sourcePath, relativePath, dataPaths);
+    } else {
+      copyToAllStoragePaths(sourcePath, relativePath, dataPaths);
+    }
+  }
+}
+function syncMetadataToAll(agentCorePath, dataPaths) {
+  const metadataDirs = ["knowledge", "refs", "tasks"];
+  for (const dir of metadataDirs) {
+    const sourceDir = path.join(agentCorePath, dir);
+    copyDirToAllStoragePaths(sourceDir, dir, dataPaths);
+  }
+}
+function checkWriteAccess(dirPath) {
+  const testFile = path.join(dirPath, ".rrce-write-test");
+  try {
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+    }
+    fs.writeFileSync(testFile, "write-test");
+    fs.unlinkSync(testFile);
+    return true;
+  } catch {
+    try {
+      if (fs.existsSync(testFile)) {
+        fs.unlinkSync(testFile);
+      }
+    } catch {
+    }
+    return false;
+  }
+}
+function getDefaultRRCEHome() {
+  return process.env.RRCE_HOME || path.join(process.env.HOME || "~", ".rrce-workflow");
+}
+function getEffectiveRRCEHome(workspaceRoot) {
+  if (workspaceRoot) {
+    const configPath = getConfigPath(workspaceRoot);
+    if (fs.existsSync(configPath)) {
+      try {
+        const content = fs.readFileSync(configPath, "utf-8");
+        const globalPathMatch = content.match(/globalPath:\s*["']?([^"'\n]+)["']?/);
+        if (globalPathMatch?.[1]) {
+          return globalPathMatch[1].trim();
+        }
+      } catch {
+      }
+    }
+  }
+  return getDefaultRRCEHome();
+}
+
+// src/lib/detection.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+function scanForProjects(options = {}) {
+  const { excludeWorkspace, workspacePath, scanSiblings = true } = options;
+  const projects = [];
+  const seenPaths = /* @__PURE__ */ new Set();
+  const globalProjects = scanGlobalStorage(excludeWorkspace);
+  for (const project of globalProjects) {
+    if (!seenPaths.has(project.path)) {
+      seenPaths.add(project.path);
+      projects.push(project);
+    }
+  }
+  if (scanSiblings && workspacePath) {
+    const siblingProjects = scanSiblingDirectories(workspacePath, excludeWorkspace);
+    for (const project of siblingProjects) {
+      if (!seenPaths.has(project.path)) {
+        seenPaths.add(project.path);
+        projects.push(project);
+      }
+    }
+  }
+  return projects;
+}
+function scanGlobalStorage(excludeWorkspace) {
+  const rrceHome = getDefaultRRCEHome();
+  const workspacesDir = path2.join(rrceHome, "workspaces");
+  const projects = [];
+  if (!fs2.existsSync(workspacesDir)) {
+    return projects;
+  }
+  try {
+    const entries = fs2.readdirSync(workspacesDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name === excludeWorkspace) continue;
+      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: fs2.existsSync(knowledgePath) ? knowledgePath : void 0,
+        refsPath: fs2.existsSync(refsPath) ? refsPath : void 0,
+        tasksPath: fs2.existsSync(tasksPath) ? tasksPath : void 0
+      });
+    }
+  } catch {
+  }
+  return projects;
+}
+function scanSiblingDirectories(workspacePath, excludeWorkspace) {
+  const parentDir = path2.dirname(workspacePath);
+  const projects = [];
+  try {
+    const entries = fs2.readdirSync(parentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const projectPath = path2.join(parentDir, entry.name);
+      if (projectPath === workspacePath) continue;
+      if (entry.name === excludeWorkspace) continue;
+      const configPath = path2.join(projectPath, ".rrce-workflow", "config.yaml");
+      if (!fs2.existsSync(configPath)) continue;
+      const config = parseWorkspaceConfig(configPath);
+      if (!config) continue;
+      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: fs2.existsSync(knowledgePath) ? knowledgePath : void 0,
+        refsPath: fs2.existsSync(refsPath) ? refsPath : void 0,
+        tasksPath: fs2.existsSync(tasksPath) ? tasksPath : void 0
+      });
+    }
+  } catch {
+  }
+  return projects;
+}
+function parseWorkspaceConfig(configPath) {
+  try {
+    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 = [];
+    const linkedMatch = content.match(/linked_projects:\s*\n((?:\s+-\s+[^\n]+\n?)+)/);
+    if (linkedMatch && linkedMatch[1]) {
+      const lines = linkedMatch[1].split("\n");
+      for (const line of lines) {
+        const projectMatch = line.match(/^\s+-\s+(.+)$/);
+        if (projectMatch && projectMatch[1]) {
+          linkedProjects.push(projectMatch[1].trim());
+        }
+      }
+    }
+    return {
+      name: nameMatch?.[1]?.trim() || path2.basename(path2.dirname(path2.dirname(configPath))),
+      storageMode: modeMatch?.[1] || "global",
+      linkedProjects: linkedProjects.length > 0 ? linkedProjects : void 0
+    };
+  } catch {
+    return null;
+  }
+}
+function getProjectDisplayLabel(project) {
+  switch (project.source) {
+    case "global":
+      return `global: ~/.rrce-workflow/workspaces/${project.name}`;
+    case "sibling":
+      return `sibling: ${project.path}/.rrce-workflow`;
+    default:
+      return project.dataPath;
+  }
+}
+function getProjectFolders(project) {
+  const folders = [];
+  if (project.knowledgePath) {
+    folders.push({
+      path: project.knowledgePath,
+      type: "knowledge",
+      displayName: `\u{1F4DA} ${project.name} (knowledge)`
+    });
+  }
+  if (project.refsPath) {
+    folders.push({
+      path: project.refsPath,
+      type: "refs",
+      displayName: `\u{1F4CE} ${project.name} (refs)`
+    });
+  }
+  if (project.tasksPath) {
+    folders.push({
+      path: project.tasksPath,
+      type: "tasks",
+      displayName: `\u{1F4CB} ${project.name} (tasks)`
+    });
+  }
+  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`);
+  let workspace;
+  if (fs5.existsSync(workspaceFilePath)) {
+    try {
+      const content = fs5.readFileSync(workspaceFilePath, "utf-8");
+      workspace = JSON.parse(content);
+    } catch {
+      workspace = { folders: [], settings: {} };
+    }
+  } else {
+    workspace = { folders: [], settings: {} };
+  }
+  if (!workspace.settings) {
+    workspace.settings = {};
+  }
+  const existingNonReferencesFolders = workspace.folders.filter(
+    (f) => f.path === "." || !f.name?.includes(REFERENCE_GROUP_PREFIX) && !f.name?.startsWith("\u{1F4DA}") && !f.name?.startsWith("\u{1F4CE}") && !f.name?.startsWith("\u{1F4CB}")
+  );
+  workspace.folders = [];
+  const mainFolder = {
+    path: ".",
+    name: `\u{1F3E0} ${workspaceName} (workspace)`
+  };
+  workspace.folders.push(mainFolder);
+  for (const folder of existingNonReferencesFolders) {
+    if (folder.path !== ".") {
+      workspace.folders.push(folder);
+    }
+  }
+  const referenceFolderPaths = [];
+  const isDetectedProjects = linkedProjects.length > 0 && typeof linkedProjects[0] === "object";
+  if (isDetectedProjects) {
+    const projects = linkedProjects;
+    for (const project of projects) {
+      const folders = getProjectFolders(project);
+      const sourceLabel = project.source === "global" ? "global" : "local";
+      for (const folder of folders) {
+        referenceFolderPaths.push(folder.path);
+        const existingIndex = workspace.folders.findIndex((f) => f.path === folder.path);
+        if (existingIndex === -1) {
+          workspace.folders.push({
+            path: folder.path,
+            name: `${folder.displayName} [${sourceLabel}]`
+          });
+        }
+      }
+    }
+  } else {
+    const projectNames = linkedProjects;
+    const rrceHome = customGlobalPath || getRRCEHome();
+    for (const projectName of projectNames) {
+      const projectDataPath = path5.join(rrceHome, "workspaces", projectName);
+      const folderTypes = [
+        { subpath: "knowledge", icon: "\u{1F4DA}", type: "knowledge" },
+        { subpath: "refs", icon: "\u{1F4CE}", type: "refs" },
+        { subpath: "tasks", icon: "\u{1F4CB}", type: "tasks" }
+      ];
+      for (const { subpath, icon, type } of folderTypes) {
+        const folderPath = path5.join(projectDataPath, subpath);
+        if (fs5.existsSync(folderPath)) {
+          referenceFolderPaths.push(folderPath);
+          const existingIndex = workspace.folders.findIndex((f) => f.path === folderPath);
+          if (existingIndex === -1) {
+            workspace.folders.push({
+              path: folderPath,
+              name: `${icon} ${projectName} (${type}) [global]`
+            });
+          }
+        }
+      }
+    }
+  }
+  if (referenceFolderPaths.length > 0) {
+    const readonlyPatterns = {};
+    for (const folderPath of referenceFolderPaths) {
+      readonlyPatterns[`${folderPath}/**`] = true;
+    }
+    const existingReadonly = workspace.settings["files.readonlyInclude"] || {};
+    workspace.settings["files.readonlyInclude"] = {
+      ...existingReadonly,
+      ...readonlyPatterns
+    };
+  }
+  workspace.settings["explorer.sortOrder"] = workspace.settings["explorer.sortOrder"] || "default";
+  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();
+  const config = await group(
+    {
+      storageMode: () => select({
+        message: "Where should workflow data be stored?",
+        options: [
+          { value: "global", label: "Global (~/.rrce-workflow/)" },
+          { value: "workspace", label: "Workspace (.rrce-workflow/)" },
+          { value: "both", label: "Both" }
+        ],
+        initialValue: "global"
+      }),
+      tools: () => multiselect({
+        message: "Which AI tools do you use?",
+        options: [
+          { value: "copilot", label: "GitHub Copilot", hint: "VSCode" },
+          { value: "antigravity", label: "Antigravity IDE" }
+        ],
+        required: false
+      }),
+      linkedProjects: () => {
+        if (existingProjects.length === 0) {
+          return Promise.resolve([]);
+        }
+        return multiselect({
+          message: "Link knowledge from other projects?",
+          options: existingProjects.map((project) => ({
+            value: project.name,
+            label: project.name,
+            hint: pc2.dim(getProjectDisplayLabel(project))
+          })),
+          required: false
+        });
+      },
+      confirm: () => confirm({
+        message: "Create configuration?",
+        initialValue: true
+      })
+    },
+    {
+      onCancel: () => {
+        cancel("Setup process cancelled.");
+        process.exit(0);
+      }
+    }
+  );
+  if (!config.confirm) {
+    outro("Setup cancelled by user.");
+    process.exit(0);
+  }
+  let customGlobalPath;
+  if (config.storageMode === "global" || config.storageMode === "both") {
+    customGlobalPath = await resolveGlobalPath();
+    if (!customGlobalPath) {
+      cancel("Setup cancelled - no writable global path available.");
+      process.exit(1);
+    }
+  }
+  s.start("Generating configuration");
+  try {
+    await generateConfiguration({
+      storageMode: config.storageMode,
+      globalPath: customGlobalPath,
+      tools: config.tools,
+      linkedProjects: config.linkedProjects
+    }, workspacePath, workspaceName, existingProjects);
+    s.stop("Configuration generated");
+    const dataPaths = getDataPaths(
+      config.storageMode,
+      workspaceName,
+      workspacePath,
+      customGlobalPath
+    );
+    const summary = [
+      `Storage: ${config.storageMode === "both" ? "global + workspace" : config.storageMode}`
+    ];
+    if (customGlobalPath && customGlobalPath !== getDefaultRRCEHome()) {
+      summary.push(`Global path: ${pc2.cyan(customGlobalPath)}`);
+    }
+    if (dataPaths.length > 0) {
+      summary.push(`Data paths:`);
+      dataPaths.forEach((p) => summary.push(`  - ${p}`));
+    }
+    const selectedTools = config.tools;
+    if (selectedTools.length > 0) {
+      summary.push(`Tools: ${selectedTools.join(", ")}`);
+    }
+    const linkedProjects = config.linkedProjects;
+    if (linkedProjects.length > 0) {
+      summary.push(`Linked projects: ${linkedProjects.join(", ")}`);
+      summary.push(`Workspace file: ${pc2.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.`));
+    } else {
+      outro(pc2.green(`\u2713 Setup complete! Your agents are ready to use.`));
+    }
+  } catch (error) {
+    s.stop("Error occurred");
+    cancel(`Failed to setup: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}
+async function resolveGlobalPath() {
+  const defaultPath = getDefaultRRCEHome();
+  const isDefaultWritable = checkWriteAccess(defaultPath);
+  const options = [];
+  options.push({
+    value: "default",
+    label: `Default (${defaultPath})`,
+    hint: isDefaultWritable ? pc2.green("\u2713 writable") : pc2.red("\u2717 not writable")
+  });
+  options.push({
+    value: "custom",
+    label: "Custom path",
+    hint: "Specify your own directory"
+  });
+  const choice = await select({
+    message: "Global storage location:",
+    options,
+    initialValue: isDefaultWritable ? "default" : "custom"
+  });
+  if (isCancel2(choice)) {
+    return void 0;
+  }
+  if (choice === "default") {
+    if (!isDefaultWritable) {
+      note(
+        `${pc2.yellow("\u26A0")} Cannot write to default path:
+  ${pc2.dim(defaultPath)}
+
+This can happen when running via npx/bunx in restricted environments.
+Please choose a custom path instead.`,
+        "Write Access Issue"
+      );
+      return resolveGlobalPath();
+    }
+    return defaultPath;
+  }
+  const suggestedPath = path7.join(process.env.HOME || "~", ".local", "share", "rrce-workflow");
+  const customPath = await directoryAutocomplete({
+    message: "Enter custom global path:",
+    initialValue: suggestedPath,
+    hint: "Tab to autocomplete",
+    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.`;
+      }
+      return void 0;
+    }
+  });
+  if (isCancel(customPath)) {
+    return void 0;
+  }
+  return customPath;
+}
+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"));
+  }
+  const agentCoreDir = getAgentCoreDir();
+  syncMetadataToAll(agentCoreDir, dataPaths);
+  copyDirToAllStoragePaths(path7.join(agentCoreDir, "templates"), "templates", dataPaths);
+  const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
+  if (config.tools.includes("copilot")) {
+    const copilotPath = getAgentPromptPath(workspacePath, "copilot");
+    ensureDir(copilotPath);
+    copyPromptsToDir(prompts, copilotPath, ".agent.md");
+  }
+  if (config.tools.includes("antigravity")) {
+    const antigravityPath = getAgentPromptPath(workspacePath, "antigravity");
+    ensureDir(antigravityPath);
+    copyPromptsToDir(prompts, antigravityPath, ".md");
+  }
+  const workspaceConfigPath = path7.join(workspacePath, ".rrce-workflow", "config.yaml");
+  ensureDir(path7.dirname(workspaceConfigPath));
+  let configContent = `# RRCE-Workflow Configuration
+version: 1
+
+storage:
+  mode: ${config.storageMode}`;
+  if (config.globalPath && config.globalPath !== getDefaultRRCEHome()) {
+    configContent += `
+  globalPath: "${config.globalPath}"`;
+  }
+  configContent += `
+
+project:
+  name: "${workspaceName}"
+
+tools:
+  copilot: ${config.tools.includes("copilot")}
+  antigravity: ${config.tools.includes("antigravity")}
+`;
+  if (config.linkedProjects.length > 0) {
+    configContent += `
+linked_projects:
+`;
+    config.linkedProjects.forEach((name) => {
+      configContent += `  - ${name}
+`;
+    });
+  }
+  fs7.writeFileSync(workspaceConfigPath, configContent);
+  if (config.tools.includes("copilot") || config.linkedProjects.length > 0) {
+    const selectedProjects = allProjects.filter((p) => config.linkedProjects.includes(p.name));
+    generateVSCodeWorkspace(workspacePath, workspaceName, selectedProjects, config.globalPath);
+  }
+}
+function getDataPaths(mode, workspaceName, workspaceRoot, customGlobalPath) {
+  const globalPath = path7.join(customGlobalPath || getDefaultRRCEHome(), "workspaces", workspaceName);
+  const workspacePath = path7.join(workspaceRoot, ".rrce-workflow");
+  switch (mode) {
+    case "global":
+      return [globalPath];
+    case "workspace":
+      return [workspacePath];
+    case "both":
+      return [workspacePath, globalPath];
+    default:
+      return [globalPath];
+  }
+}
+
+// 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";
+async function runLinkProjectsFlow(workspacePath, workspaceName) {
+  const projects = scanForProjects({
+    excludeWorkspace: workspaceName,
+    workspacePath,
+    scanSiblings: true
+  });
+  if (projects.length === 0) {
+    outro2(pc3.yellow("No other projects found. Try setting up another project first."));
+    return;
+  }
+  const customGlobalPath = getEffectiveRRCEHome(workspacePath);
+  const linkedProjects = await multiselect2({
+    message: "Select projects to link:",
+    options: projects.map((project) => ({
+      value: project.name,
+      label: project.name,
+      hint: pc3.dim(getProjectDisplayLabel(project))
+    })),
+    required: true
+  });
+  if (isCancel3(linkedProjects)) {
+    cancel2("Cancelled.");
+    process.exit(0);
+  }
+  const selectedProjectNames = linkedProjects;
+  if (selectedProjectNames.length === 0) {
+    outro2("No projects selected.");
+    return;
+  }
+  const selectedProjects = projects.filter((p) => selectedProjectNames.includes(p.name));
+  const s = spinner2();
+  s.start("Linking projects");
+  const configFilePath = getConfigPath(workspacePath);
+  let configContent = fs8.readFileSync(configFilePath, "utf-8");
+  if (configContent.includes("linked_projects:")) {
+    const lines = configContent.split("\n");
+    const linkedIndex = lines.findIndex((l) => l.trim() === "linked_projects:");
+    if (linkedIndex !== -1) {
+      let insertIndex = linkedIndex + 1;
+      while (insertIndex < lines.length && lines[insertIndex]?.startsWith("  - ")) {
+        insertIndex++;
+      }
+      for (const name of selectedProjectNames) {
+        if (!configContent.includes(`  - ${name}`)) {
+          lines.splice(insertIndex, 0, `  - ${name}`);
+          insertIndex++;
+        }
+      }
+      configContent = lines.join("\n");
+    }
+  } else {
+    configContent += `
+linked_projects:
+`;
+    selectedProjectNames.forEach((name) => {
+      configContent += `  - ${name}
+`;
+    });
+  }
+  fs8.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})`)}`),
+    ``,
+    `Workspace file: ${pc3.cyan(workspaceFile)}`,
+    ``,
+    pc3.dim("Includes: knowledge, refs, tasks folders")
+  ];
+  note2(summary.join("\n"), "Link Summary");
+  outro2(pc3.green(`\u2713 Projects linked! Open ${pc3.bold(workspaceFile)} in VSCode to access linked knowledge.`));
+}
+
+// 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";
+async function runSyncToGlobalFlow(workspacePath, workspaceName) {
+  const localPath = getLocalWorkspacePath(workspacePath);
+  const customGlobalPath = getEffectiveRRCEHome(workspacePath);
+  const globalPath = path8.join(customGlobalPath, "workspaces", workspaceName);
+  const subdirs = ["knowledge", "prompts", "templates", "tasks", "refs"];
+  const existingDirs = subdirs.filter(
+    (dir) => fs9.existsSync(path8.join(localPath, dir))
+  );
+  if (existingDirs.length === 0) {
+    outro3(pc4.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)}`,
+    "Sync Preview"
+  );
+  const shouldSync = await confirm2({
+    message: "Proceed with sync to global storage?",
+    initialValue: true
+  });
+  if (isCancel4(shouldSync) || !shouldSync) {
+    outro3("Sync cancelled.");
+    return;
+  }
+  const s = spinner3();
+  s.start("Syncing to global storage");
+  try {
+    ensureDir(globalPath);
+    for (const dir of existingDirs) {
+      const srcDir = path8.join(localPath, dir);
+      const destDir = path8.join(globalPath, dir);
+      ensureDir(destDir);
+      copyDirRecursive(srcDir, destDir);
+    }
+    const configFilePath = getConfigPath(workspacePath);
+    let configContent = fs9.readFileSync(configFilePath, "utf-8");
+    configContent = configContent.replace(/mode:\s*workspace/, "mode: both");
+    fs9.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")}`,
+      ``,
+      `Other projects can now link this knowledge!`
+    ];
+    note3(summary.join("\n"), "Sync Summary");
+    outro3(pc4.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)}`);
+    process.exit(1);
+  }
+}
+
+// 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";
+async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
+  const s = spinner4();
+  s.start("Checking for updates");
+  try {
+    const agentCoreDir = getAgentCoreDir();
+    const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
+    const mode = currentStorageMode || "global";
+    const customGlobalPath = getEffectiveRRCEHome(workspacePath);
+    const dataPaths = resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspacePath, customGlobalPath);
+    s.stop("Updates found");
+    note4(
+      `The following will be updated from the package:
+  \u2022 prompts/ (${prompts.length} agent prompts)
+  \u2022 templates/ (output templates)
+
+Target locations:
+${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
+      "Update Preview"
+    );
+    const shouldUpdate = await confirm3({
+      message: "Proceed with update?",
+      initialValue: true
+    });
+    if (isCancel5(shouldUpdate) || !shouldUpdate) {
+      outro4("Update cancelled.");
+      return;
+    }
+    s.start("Updating from package");
+    for (const dataPath of dataPaths) {
+      copyDirToAllStoragePaths(path9.join(agentCoreDir, "templates"), "templates", [dataPath]);
+    }
+    const configFilePath = getConfigPath(workspacePath);
+    const configContent = fs10.readFileSync(configFilePath, "utf-8");
+    if (configContent.includes("copilot: true")) {
+      const copilotPath = getAgentPromptPath(workspacePath, "copilot");
+      ensureDir(copilotPath);
+      copyPromptsToDir(prompts, copilotPath, ".agent.md");
+    }
+    if (configContent.includes("antigravity: true")) {
+      const antigravityPath = getAgentPromptPath(workspacePath, "antigravity");
+      ensureDir(antigravityPath);
+      copyPromptsToDir(prompts, antigravityPath, ".md");
+    }
+    s.stop("Update complete");
+    const summary = [
+      `Updated:`,
+      `  \u2713 ${prompts.length} agent prompts`,
+      `  \u2713 Output templates`,
+      ``,
+      `Your configuration and knowledge files were preserved.`
+    ];
+    note4(summary.join("\n"), "Update Summary");
+    outro4(pc5.green("\u2713 Successfully updated from package!"));
+  } catch (error) {
+    s.stop("Error occurred");
+    cancel4(`Failed to update: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}
+function resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspaceRoot, customGlobalPath) {
+  const globalPath = path9.join(customGlobalPath, "workspaces", workspaceName);
+  const workspacePath = path9.join(workspaceRoot, ".rrce-workflow");
+  switch (mode) {
+    case "global":
+      return [globalPath];
+    case "workspace":
+      return [workspacePath];
+    case "both":
+      return [workspacePath, globalPath];
+    default:
+      return [globalPath];
+  }
+}
+
+// src/commands/wizard/index.ts
+async function runWizard() {
+  intro(pc6.cyan(pc6.inverse(" RRCE-Workflow Setup ")));
+  const s = spinner5();
+  s.start("Detecting environment");
+  const workspacePath = detectWorkspaceRoot();
+  const workspaceName = getWorkspaceName(workspacePath);
+  const gitUser = getGitUser();
+  await new Promise((r) => setTimeout(r, 800));
+  s.stop("Environment detected");
+  note5(
+    `Git User:  ${pc6.bold(gitUser || "(not found)")}
+Workspace: ${pc6.bold(workspaceName)}`,
+    "Context"
+  );
+  const detectedProjects = scanForProjects({
+    excludeWorkspace: workspaceName,
+    workspacePath,
+    scanSiblings: true
+  });
+  const configFilePath = getConfigPath(workspacePath);
+  const isAlreadyConfigured = fs11.existsSync(configFilePath);
+  let currentStorageMode = null;
+  if (isAlreadyConfigured) {
+    try {
+      const configContent = fs11.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);
+  if (isAlreadyConfigured) {
+    const menuOptions = [];
+    if (detectedProjects.length > 0) {
+      menuOptions.push({
+        value: "link",
+        label: "Link other project knowledge",
+        hint: `${detectedProjects.length} projects detected (global + sibling)`
+      });
+    }
+    if (currentStorageMode === "workspace" && hasLocalData) {
+      menuOptions.push({
+        value: "sync-global",
+        label: "Sync to global storage",
+        hint: "Share knowledge with other projects"
+      });
+    }
+    menuOptions.push({ value: "update", label: "Update from package", hint: "Get latest prompts & templates" });
+    menuOptions.push({ value: "exit", label: "Exit" });
+    const action = await select2({
+      message: "This workspace is already configured. What would you like to do?",
+      options: menuOptions
+    });
+    if (isCancel6(action) || action === "exit") {
+      outro5("Exited.");
+      process.exit(0);
+    }
+    if (action === "link") {
+      await runLinkProjectsFlow(workspacePath, workspaceName);
+      return;
+    }
+    if (action === "sync-global") {
+      await runSyncToGlobalFlow(workspacePath, workspaceName);
+      return;
+    }
+    if (action === "update") {
+      await runUpdateFlow(workspacePath, workspaceName, currentStorageMode);
+      return;
+    }
+  }
+  await runSetupFlow(workspacePath, workspaceName, detectedProjects);
+}
+
+// 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";
+async function runSelector() {
+  const workspaceName = path10.basename(process.cwd());
+  intro2(pc7.cyan(pc7.inverse(` RRCE-Workflow | ${workspaceName} `)));
+  const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
+  if (prompts.length === 0) {
+    cancel6("No agents found. Run `rrce-workflow` to set up.");
+    process.exit(0);
+  }
+  const selection = await select3({
+    message: "Select an agent:",
+    options: prompts.map((p) => ({
+      value: p,
+      label: p.frontmatter.name,
+      hint: p.frontmatter.description
+    }))
+  });
+  if (isCancel7(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}`))}`,
+    "Agent Selected"
+  );
+  outro6("Done");
+}
+
+// src/index.ts
+var command = process.argv[2];
+if (!command || command === "wizard") {
+  runWizard();
+} else {
+  runSelector();
+}