rrce-workflow 0.2.77 → 0.2.79

package/dist/index.js

@@ -1032,14 +1032,15 @@ function isVSCodeInstalled() {
   const configDir = path6.join(os.homedir(), ".config/Code/User");
   return fs5.existsSync(configDir);
 }
-var ANTIGRAVITY_CONFIG, CLAUDE_CONFIG, VSCODE_GLOBAL_CONFIG, OPENCODE_CONFIG;
+var ANTIGRAVITY_CONFIG, CLAUDE_CONFIG, VSCODE_GLOBAL_CONFIG, OPENCODE_CONFIG_DIR, OPENCODE_CONFIG;
 var init_install = __esm({
   "src/mcp/install.ts"() {
     "use strict";
     ANTIGRAVITY_CONFIG = path6.join(os.homedir(), ".gemini/antigravity/mcp_config.json");
     CLAUDE_CONFIG = path6.join(os.homedir(), ".config/claude/claude_desktop_config.json");
     VSCODE_GLOBAL_CONFIG = path6.join(os.homedir(), ".config/Code/User/settings.json");
-    OPENCODE_CONFIG = path6.join(os.homedir(), ".config/opencode/opencode.json");
+    OPENCODE_CONFIG_DIR = path6.join(os.homedir(), ".config/opencode");
+    OPENCODE_CONFIG = path6.join(OPENCODE_CONFIG_DIR, "opencode.json");
   }
 });
 
@@ -1249,7 +1250,7 @@ var init_prompts = __esm({
 // src/commands/wizard/utils.ts
 import * as fs7 from "fs";
 import * as path8 from "path";
-import { stringify } from "yaml";
+import "yaml";
 function copyPromptsToDir(prompts, targetDir, extension) {
   for (const prompt of prompts) {
     const baseName = path8.basename(prompt.filePath, ".md");
@@ -1261,29 +1262,24 @@ function copyPromptsToDir(prompts, targetDir, extension) {
 }
 function convertToOpenCodeAgent(prompt) {
   const { frontmatter, content } = prompt;
-  const tools = {
-    // Enable standard host tools by default
-    "read": true,
-    "write": true,
-    "edit": true,
-    "bash": true,
-    "grep": true,
-    "glob": true,
-    "webfetch": true
-  };
+  const tools = {};
+  const hostTools = ["read", "write", "edit", "bash", "grep", "glob", "webfetch", "terminalLastCommand"];
   if (frontmatter.tools) {
     for (const tool of frontmatter.tools) {
-      tools[`rrce_${tool}`] = true;
+      if (hostTools.includes(tool)) {
+        tools[tool] = true;
+      } else {
+        tools[`rrce_${tool}`] = true;
+      }
     }
   }
-  const opencodeFrontmatter = {
+  tools["webfetch"] = true;
+  return {
     description: frontmatter.description,
     mode: "primary",
+    prompt: content,
     tools
   };
-  return `---
-${stringify(opencodeFrontmatter)}---
-${content}`;
 }
 function copyDirRecursive(src, dest) {
   const entries = fs7.readdirSync(src, { withFileTypes: true });
@@ -1657,6 +1653,7 @@ import * as fs10 from "fs";
 import * as path12 from "path";
 import pc4 from "picocolors";
 import { note as note2 } from "@clack/prompts";
+import { stringify as stringify2 } from "yaml";
 function createDirectoryStructure(dataPaths) {
   for (const dataPath of dataPaths) {
     ensureDir(dataPath);
@@ -1666,7 +1663,7 @@ function createDirectoryStructure(dataPaths) {
     ensureDir(path12.join(dataPath, "templates"));
   }
 }
-function installAgentPrompts(config, workspacePath, dataPaths) {
+async function installAgentPrompts(config, workspacePath, dataPaths) {
   const agentCoreDir = getAgentCoreDir();
   syncMetadataToAll(agentCoreDir, dataPaths);
   copyDirToAllStoragePaths(path12.join(agentCoreDir, "templates"), "templates", dataPaths);
@@ -1695,30 +1692,36 @@ function installAgentPrompts(config, workspacePath, dataPaths) {
     if (config.tools.includes("opencode")) {
       const primaryDataPath = dataPaths[0];
       if (primaryDataPath) {
-        const opencodePath = path12.join(primaryDataPath, ".opencode", "agent");
-        ensureDir(opencodePath);
-        for (const prompt of prompts) {
-          const baseName = path12.basename(prompt.filePath, ".md");
-          const content = convertToOpenCodeAgent(prompt);
-          fs10.writeFileSync(path12.join(opencodePath, `${baseName}.md`), content);
-        }
         if (config.storageMode === "global") {
-          const workspaceOpencode = path12.join(workspacePath, ".opencode");
-          const globalOpencode = path12.join(primaryDataPath, ".opencode");
           try {
-            if (fs10.existsSync(workspaceOpencode)) {
-              fs10.rmSync(workspaceOpencode, { recursive: true, force: true });
-            } else {
-              try {
-                if (fs10.lstatSync(workspaceOpencode).isSymbolicLink()) {
-                  fs10.unlinkSync(workspaceOpencode);
-                }
-              } catch (e) {
-              }
+            let opencodeConfig = { $schema: "https://opencode.ai/config.json" };
+            if (fs10.existsSync(OPENCODE_CONFIG)) {
+              opencodeConfig = JSON.parse(fs10.readFileSync(OPENCODE_CONFIG, "utf-8"));
             }
-            fs10.symlinkSync(globalOpencode, workspaceOpencode, "dir");
+            if (!opencodeConfig.agent) opencodeConfig.agent = {};
+            for (const prompt of prompts) {
+              const baseName = path12.basename(prompt.filePath, ".md");
+              const agentConfig = convertToOpenCodeAgent(prompt);
+              opencodeConfig.agent[baseName] = agentConfig;
+            }
+            fs10.writeFileSync(OPENCODE_CONFIG, JSON.stringify(opencodeConfig, null, 2) + "\n");
           } catch (e) {
-            console.error(`Warning: Could not create OpenCode symlink at ${workspaceOpencode}:`, e instanceof Error ? e.message : String(e));
+            console.error("Failed to update global OpenCode config with agents:", e);
+          }
+        } else {
+          const opencodeBaseDir = path12.join(primaryDataPath, ".opencode", "agent");
+          ensureDir(opencodeBaseDir);
+          for (const prompt of prompts) {
+            const baseName = path12.basename(prompt.filePath, ".md");
+            const agentConfig = convertToOpenCodeAgent(prompt);
+            const content = `---
+${stringify2({
+              description: agentConfig.description,
+              mode: agentConfig.mode,
+              tools: agentConfig.tools
+            })}---
+${agentConfig.prompt}`;
+            fs10.writeFileSync(path12.join(opencodeBaseDir, `${baseName}.md`), content);
           }
         }
       }
@@ -1857,13 +1860,15 @@ function updateGitignore(workspacePath, storageMode, tools) {
   const entries = [];
   if (storageMode === "workspace") {
     entries.push(".rrce-workflow/");
-  }
-  entries.push(".opencode/");
-  if (tools.includes("copilot")) {
-    entries.push(".github/agents/");
-  }
-  if (tools.includes("antigravity")) {
-    entries.push(".agent/workflows/");
+    if (tools.includes("opencode")) {
+      entries.push(".opencode/");
+    }
+    if (tools.includes("copilot")) {
+      entries.push(".github/agents/");
+    }
+    if (tools.includes("antigravity")) {
+      entries.push(".agent/workflows/");
+    }
   }
   entries.push("*.code-workspace");
   if (entries.length === 0) {
@@ -2206,6 +2211,7 @@ var init_rag = __esm({
 // src/mcp/resources.ts
 import * as fs14 from "fs";
 import * as path16 from "path";
+import * as crypto from "crypto";
 function getExposedProjects() {
   const config = loadMCPConfig();
   const knownPaths = config.projects.map((p) => p.path).filter((p) => !!p);
@@ -2526,9 +2532,101 @@ All file operations should be relative to WORKSPACE_ROOT shown above.
 `;
   return contextPreamble;
 }
+function getTask(projectName, taskSlug) {
+  const config = loadMCPConfig();
+  const projects = projectService.scan();
+  const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.path));
+  if (!project || !project.tasksPath) return null;
+  const metaPath = path16.join(project.tasksPath, taskSlug, "meta.json");
+  if (!fs14.existsSync(metaPath)) return null;
+  try {
+    return JSON.parse(fs14.readFileSync(metaPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+async function createTask(projectName, taskSlug, taskData) {
+  const config = loadMCPConfig();
+  const projects = projectService.scan();
+  const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.path));
+  if (!project || !project.tasksPath) {
+    throw new Error(`Project '${projectName}' not found or not configured with a tasks path.`);
+  }
+  const taskDir = path16.join(project.tasksPath, taskSlug);
+  if (fs14.existsSync(taskDir)) {
+    throw new Error(`Task with slug '${taskSlug}' already exists.`);
+  }
+  fs14.mkdirSync(taskDir, { recursive: true });
+  fs14.mkdirSync(path16.join(taskDir, "research"), { recursive: true });
+  fs14.mkdirSync(path16.join(taskDir, "planning"), { recursive: true });
+  fs14.mkdirSync(path16.join(taskDir, "execution"), { recursive: true });
+  fs14.mkdirSync(path16.join(taskDir, "docs"), { recursive: true });
+  const rrceHome = process.env.RRCE_HOME || path16.join(__require("os").homedir(), ".rrce-workflow");
+  const templatePath = path16.join(rrceHome, "templates", "meta.template.json");
+  let meta = {
+    task_id: crypto.randomUUID(),
+    task_slug: taskSlug,
+    status: "draft",
+    agents: {}
+  };
+  if (fs14.existsSync(templatePath)) {
+    try {
+      const template = JSON.parse(fs14.readFileSync(templatePath, "utf-8"));
+      meta = { ...template, ...meta };
+    } catch (e) {
+      logger.error("Failed to load meta template", e);
+    }
+  }
+  meta.created_at = (/* @__PURE__ */ new Date()).toISOString();
+  meta.updated_at = meta.created_at;
+  meta.workspace = {
+    name: project.name,
+    path: project.path || project.dataPath,
+    hash: project.name
+  };
+  Object.assign(meta, taskData);
+  const metaPath = path16.join(taskDir, "meta.json");
+  fs14.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
+  return meta;
+}
+async function updateTask(projectName, taskSlug, taskData) {
+  const meta = getTask(projectName, taskSlug);
+  if (!meta) throw new Error(`Task '${taskSlug}' not found.`);
+  const updatedMeta = {
+    ...meta,
+    ...taskData,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    // Ensure nested objects are merged if they exist in taskData
+    agents: taskData.agents ? { ...meta.agents, ...taskData.agents } : meta.agents,
+    workspace: meta.workspace
+    // Protect workspace metadata
+  };
+  const config = loadMCPConfig();
+  const projects = projectService.scan();
+  const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.path));
+  if (!project || !project.tasksPath) return null;
+  const metaPath = path16.join(project.tasksPath, taskSlug, "meta.json");
+  fs14.writeFileSync(metaPath, JSON.stringify(updatedMeta, null, 2));
+  return updatedMeta;
+}
+function deleteTask(projectName, taskSlug) {
+  const config = loadMCPConfig();
+  const projects = projectService.scan();
+  const project = projects.find((p) => p.name === projectName && isProjectExposed(config, p.name, p.path));
+  if (!project || !project.tasksPath) return false;
+  const taskDir = path16.join(project.tasksPath, taskSlug);
+  if (!fs14.existsSync(taskDir)) return false;
+  if (fs14.rmSync) {
+    fs14.rmSync(taskDir, { recursive: true, force: true });
+  } else {
+    fs14.rmdirSync(taskDir, { recursive: true });
+  }
+  return true;
+}
 var init_resources = __esm({
   "src/mcp/resources.ts"() {
     "use strict";
+    init_logger();
     init_config();
     init_config_utils();
     init_detection();
@@ -2771,6 +2869,66 @@ function registerToolHandlers(server) {
           },
           required: ["agent"]
         }
+      },
+      {
+        name: "list_tasks",
+        description: "List all tasks for a project",
+        inputSchema: {
+          type: "object",
+          properties: { project: { type: "string", description: "Name of the project" } },
+          required: ["project"]
+        }
+      },
+      {
+        name: "get_task",
+        description: "Get details of a specific task",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project: { type: "string", description: "Name of the project" },
+            task_slug: { type: "string", description: "The slug of the task" }
+          },
+          required: ["project", "task_slug"]
+        }
+      },
+      {
+        name: "create_task",
+        description: "Create a new task in the project",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project: { type: "string", description: "Name of the project" },
+            task_slug: { type: "string", description: "The slug for the new task (kebab-case)" },
+            title: { type: "string", description: "The title of the task" },
+            summary: { type: "string", description: "Brief summary of the task" }
+          },
+          required: ["project", "task_slug"]
+        }
+      },
+      {
+        name: "update_task",
+        description: "Update an existing task",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project: { type: "string", description: "Name of the project" },
+            task_slug: { type: "string", description: "The slug of the task" },
+            updates: { type: "object", description: "The fields to update in meta.json", additionalProperties: true }
+          },
+          required: ["project", "task_slug", "updates"]
+        }
+      },
+      {
+        name: "delete_task",
+        description: "Delete a task from the project",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project: { type: "string", description: "Name of the project" },
+            task_slug: { type: "string", description: "The slug of the task to delete" }
+          },
+          required: ["project", "task_slug"]
+        }
       }
     ];
     const projects = getExposedProjects();
@@ -2858,6 +3016,38 @@ The system has pre-resolved the configuration for this project. Use these values
 `;
           return { content: [{ type: "text", text: contextPreamble + rendered }] };
         }
+        case "list_tasks": {
+          const params = args;
+          const tasks = getProjectTasks(params.project);
+          return { content: [{ type: "text", text: JSON.stringify(tasks, null, 2) }] };
+        }
+        case "get_task": {
+          const params = args;
+          const task = getTask(params.project, params.task_slug);
+          if (!task) {
+            return { content: [{ type: "text", text: `Task '${params.task_slug}' not found in project '${params.project}'.` }], isError: true };
+          }
+          return { content: [{ type: "text", text: JSON.stringify(task, null, 2) }] };
+        }
+        case "create_task": {
+          const params = args;
+          const taskData = {
+            title: params.title || params.task_slug,
+            summary: params.summary || ""
+          };
+          const task = await createTask(params.project, params.task_slug, taskData);
+          return { content: [{ type: "text", text: JSON.stringify(task, null, 2) }] };
+        }
+        case "update_task": {
+          const params = args;
+          const task = await updateTask(params.project, params.task_slug, params.updates);
+          return { content: [{ type: "text", text: JSON.stringify(task, null, 2) }] };
+        }
+        case "delete_task": {
+          const params = args;
+          const success = deleteTask(params.project, params.task_slug);
+          return { content: [{ type: "text", text: success ? `Task '${params.task_slug}' deleted.` : `Failed to delete task '${params.task_slug}'.` }] };
+        }
         case "help_setup": {
           const msg = `
 RRCE MCP Server is running, but no projects are configured/exposed.
@@ -4363,8 +4553,8 @@ async function runExpressSetup(workspacePath, workspaceName, existingProjects, s
 \u2022 Storage: ${storageMode === "global" ? "Global" : "Workspace"}
 \u2022 MCP Server: Enabled
 \u2022 Semantic Search (RAG): Enabled
-\u2022 Git ignore entries: Added
-\u2022 AI Tools: ${toolsText}`,
+` + (storageMode === "workspace" ? `\u2022 Git ignore entries: Added
+` : "") + `\u2022 AI Tools: ${toolsText}`,
     "Configuration Preview"
   );
   const confirmed = await confirm6({
@@ -4389,6 +4579,10 @@ async function runExpressSetup(workspacePath, workspaceName, existingProjects, s
     enableRAG: true
   };
   await executeSetup(config, workspacePath, workspaceName, existingProjects, s);
+  if (config.storageMode === "workspace") {
+    const { updateGitignore: updateGitignore2 } = await Promise.resolve().then(() => (init_gitignore(), gitignore_exports));
+    updateGitignore2(workspacePath, config.storageMode, config.tools);
+  }
   const startMCP = await confirm6({
     message: "Start MCP server now?",
     initialValue: true
@@ -4432,7 +4626,7 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
   if (storageMode !== "global") {
     linkedProjects = await promptLinkedProjects(existingProjects);
   }
-  const addToGitignore = await promptGitignore();
+  const addToGitignore = storageMode === "workspace" ? await promptGitignore() : false;
   const enableRAG = await promptRAG();
   const confirmed = await promptConfirmation();
   if (!confirmed) {
@@ -4449,6 +4643,10 @@ async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
     enableRAG
   };
   await executeSetup(config, workspacePath, workspaceName, existingProjects, s);
+  if (config.storageMode === "workspace" && config.addToGitignore) {
+    const { updateGitignore: updateGitignore2 } = await Promise.resolve().then(() => (init_gitignore(), gitignore_exports));
+    updateGitignore2(workspacePath, config.storageMode, config.tools);
+  }
   await handlePostSetup(config, workspacePath, workspaceName, linkedProjects);
 }
 async function executeSetup(config, workspacePath, workspaceName, allProjects, s) {
@@ -4456,9 +4654,9 @@ async function executeSetup(config, workspacePath, workspaceName, allProjects, s
   try {
     const dataPaths = getDataPaths(config.storageMode, workspaceName, workspacePath, config.globalPath);
     createDirectoryStructure(dataPaths);
-    installAgentPrompts(config, workspacePath, dataPaths);
+    await installAgentPrompts(config, workspacePath, dataPaths);
     createWorkspaceConfig(config, workspacePath, workspaceName);
-    if (config.addToGitignore) {
+    if (config.storageMode === "workspace" && config.addToGitignore) {
       const { updateGitignore: updateGitignore2 } = await Promise.resolve().then(() => (init_gitignore(), gitignore_exports));
       updateGitignore2(workspacePath, config.storageMode, config.tools);
     }
@@ -4713,6 +4911,7 @@ import { confirm as confirm9, spinner as spinner6, note as note12, outro as outr
 import pc14 from "picocolors";
 import * as fs18 from "fs";
 import * as path19 from "path";
+import { stringify as stringify3 } from "yaml";
 async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
   const s = spinner6();
   s.start("Checking for updates");
@@ -4723,10 +4922,25 @@ async function runUpdateFlow(workspacePath, workspaceName, currentStorageMode) {
     const customGlobalPath = getEffectiveRRCEHome(workspacePath);
     const dataPaths = resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspacePath, customGlobalPath);
     s.stop("Updates found");
+    const updateTargets = [
+      `  \u2022 prompts/ (${prompts.length} agent prompts)`,
+      `  \u2022 templates/ (output templates)`,
+      `  \u2022 docs/ (documentation)`
+    ];
+    const configFilePath = getConfigPath(workspacePath);
+    const ideTargets = [];
+    if (fs18.existsSync(configFilePath)) {
+      const configContent = fs18.readFileSync(configFilePath, "utf-8");
+      if (configContent.includes("opencode: true")) ideTargets.push("OpenCode agents");
+      if (configContent.includes("copilot: true")) ideTargets.push("GitHub Copilot");
+      if (configContent.includes("antigravity: true")) ideTargets.push("Antigravity");
+    }
+    if (ideTargets.length > 0) {
+      updateTargets.push(`  \u2022 IDE integrations: ${ideTargets.join(", ")}`);
+    }
     note12(
       `The following will be updated from the package:
-  \u2022 prompts/ (${prompts.length} agent prompts)
-  \u2022 templates/ (output templates)
+${updateTargets.join("\n")}
 
 Target locations:
 ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
@@ -4743,29 +4957,51 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
     s.start("Updating from package");
     for (const dataPath of dataPaths) {
       copyDirToAllStoragePaths(path19.join(agentCoreDir, "templates"), "templates", [dataPath]);
+      copyDirToAllStoragePaths(path19.join(agentCoreDir, "prompts"), "prompts", [dataPath]);
+      copyDirToAllStoragePaths(path19.join(agentCoreDir, "docs"), "docs", [dataPath]);
     }
-    const configFilePath = getConfigPath(workspacePath);
+    const rrceHome = customGlobalPath || getDefaultRRCEHome2();
+    ensureDir(path19.join(rrceHome, "templates"));
+    ensureDir(path19.join(rrceHome, "docs"));
+    copyDirRecursive(path19.join(agentCoreDir, "templates"), path19.join(rrceHome, "templates"));
+    copyDirRecursive(path19.join(agentCoreDir, "docs"), path19.join(rrceHome, "docs"));
     if (fs18.existsSync(configFilePath)) {
       const configContent = fs18.readFileSync(configFilePath, "utf-8");
       if (configContent.includes("copilot: true")) {
         const copilotPath = getAgentPromptPath(workspacePath, "copilot");
         ensureDir(copilotPath);
+        clearDirectory(copilotPath);
         copyPromptsToDir(prompts, copilotPath, ".agent.md");
       }
       if (configContent.includes("antigravity: true")) {
         const antigravityPath = getAgentPromptPath(workspacePath, "antigravity");
         ensureDir(antigravityPath);
+        clearDirectory(antigravityPath);
         copyPromptsToDir(prompts, antigravityPath, ".md");
       }
+      if (configContent.includes("opencode: true")) {
+        const primaryDataPath = dataPaths[0];
+        if (primaryDataPath) {
+          updateOpenCodeAgents(prompts, mode, primaryDataPath);
+        }
+      }
     }
     s.stop("Update complete");
     const summary = [
       `Updated:`,
       `  \u2713 ${prompts.length} agent prompts`,
       `  \u2713 Output templates`,
-      ``,
-      `Your configuration and knowledge files were preserved.`
+      `  \u2713 Documentation`
     ];
+    if (ideTargets.length > 0) {
+      summary.push(`  \u2713 IDE integrations: ${ideTargets.join(", ")}`);
+    }
+    summary.push(
+      ``,
+      `Your configuration and knowledge files were preserved.`,
+      ``,
+      pc14.dim(`\u{1F4A1} If using OpenCode, you may need to reload for changes to take effect.`)
+    );
     note12(summary.join("\n"), "Update Summary");
     outro5(pc14.green("\u2713 Successfully updated from package!"));
   } catch (error) {
@@ -4774,6 +5010,60 @@ ${dataPaths.map((p) => `  \u2022 ${p}`).join("\n")}`,
     process.exit(1);
   }
 }
+function updateOpenCodeAgents(prompts, mode, primaryDataPath) {
+  if (mode === "global") {
+    try {
+      let opencodeConfig = { $schema: "https://opencode.ai/config.json" };
+      if (fs18.existsSync(OPENCODE_CONFIG)) {
+        opencodeConfig = JSON.parse(fs18.readFileSync(OPENCODE_CONFIG, "utf-8"));
+      }
+      if (!opencodeConfig.agent) opencodeConfig.agent = {};
+      const currentAgentNames = prompts.map((p) => path19.basename(p.filePath, ".md"));
+      const existingAgentNames = Object.keys(opencodeConfig.agent);
+      const rrceAgentPrefixes = ["init", "research", "planning", "executor", "doctor", "documentation", "sync"];
+      for (const existingName of existingAgentNames) {
+        const isRrceAgent = rrceAgentPrefixes.some((prefix) => existingName.startsWith(prefix));
+        const stillExists = currentAgentNames.includes(existingName);
+        if (isRrceAgent && !stillExists) {
+          delete opencodeConfig.agent[existingName];
+        }
+      }
+      for (const prompt of prompts) {
+        const baseName = path19.basename(prompt.filePath, ".md");
+        const agentConfig = convertToOpenCodeAgent(prompt);
+        opencodeConfig.agent[baseName] = agentConfig;
+      }
+      fs18.writeFileSync(OPENCODE_CONFIG, JSON.stringify(opencodeConfig, null, 2) + "\n");
+    } catch (e) {
+      console.error("Failed to update global OpenCode config with agents:", e);
+    }
+  } else {
+    const opencodeBaseDir = path19.join(primaryDataPath, ".opencode", "agent");
+    ensureDir(opencodeBaseDir);
+    clearDirectory(opencodeBaseDir);
+    for (const prompt of prompts) {
+      const baseName = path19.basename(prompt.filePath, ".md");
+      const agentConfig = convertToOpenCodeAgent(prompt);
+      const content = `---
+${stringify3({
+        description: agentConfig.description,
+        mode: agentConfig.mode,
+        tools: agentConfig.tools
+      })}---
+${agentConfig.prompt}`;
+      fs18.writeFileSync(path19.join(opencodeBaseDir, `${baseName}.md`), content);
+    }
+  }
+}
+function clearDirectory(dirPath) {
+  if (!fs18.existsSync(dirPath)) return;
+  const entries = fs18.readdirSync(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isFile()) {
+      fs18.unlinkSync(path19.join(dirPath, entry.name));
+    }
+  }
+}
 function resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspaceRoot, customGlobalPath) {
   const globalPath = path19.join(customGlobalPath, "workspaces", workspaceName);
   const workspacePath = path19.join(workspaceRoot, ".rrce-workflow");
@@ -4792,6 +5082,7 @@ var init_update_flow = __esm({
     init_paths();
     init_prompts();
     init_utils();
+    init_install();
   }
 });
 

package/docs/architecture.md

@@ -7,7 +7,9 @@
 RRCE-Workflow is a TUI-based agentic code workflow generator designed to work seamlessly across:
 - **GitHub Copilot CLI**
 - **Antigravity IDE** (Google's agentic coding environment)
+- **OpenCode** (Native agentic TUI environment)
 - **VS Code** (with Copilot and other AI extensions)
+- **Claude Desktop**
 
 The system provides a structured multi-agent pipeline for software development tasks, with persistent knowledge caching and workspace-aware context management.
 
@@ -243,6 +245,7 @@ RRCE-Workflow prompts are designed to work across multiple AI coding tools:
 | Tool | Prompt Location | Extension | Notes |
 |------|----------------|-----------|-------|
 | **Antigravity IDE** | `.agent/workflows/` | `.md` | Native workflow support |
+| **OpenCode** | `.opencode/agent/` | `.md` | Custom Primary Agents |
 | **GitHub Copilot (VSCode)** | `.github/agents/` | `.agent.md` | Custom agents format |
 | **Copilot CLI** | Any location | `.md` | Reference via file path |
 
@@ -298,6 +301,17 @@ When you run `rrce-workflow wizard`, it creates:
 └── sync.md
 ```
 
+**For OpenCode:**
+```
+.opencode/agent/
+├── rrce-init.md
+├── rrce-research.md
+├── rrce-planning.md
+├── rrce-executor.md
+├── rrce-documentation.md
+└── rrce-sync.md
+```
+
 ### Copilot-Specific Features
 
 Our prompts include Copilot-compatible frontmatter:

package/package.json

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