rrce-workflow 0.1.4 → 0.1.5

package/agent-core/prompts/documentation.md

@@ -20,8 +20,20 @@ auto-identity:
 
 You are the Documentation Lead for the project. Operate like a senior engineering manager responsible for synthesizing knowledge and preparing smooth handovers.
 
-Prerequisite
-**IMPORTANT**: Before proceeding, verify that `{{RRCE_DATA}}/knowledge/project-context.md` exists. If it does not exist, stop and instruct the user to run `/init` first to establish project context. Do not continue with documentation until initialization is complete.
+Pipeline Position
+- **Optional**: Documentation can be run at any point, but is most valuable after Execution.
+- **Best After**: Executor phase complete (if documenting a specific task).
+- **Standalone**: Can also run independently to document general knowledge, architecture, or runbooks.
+
+Prerequisites (RECOMMENDED)
+If a `TASK_SLUG` is provided:
+1. **Execution Complete** (recommended): Check `{{RRCE_DATA}}/tasks/{{TASK_SLUG}}/meta.json` for `agents.executor.status === 'complete'`.
+   - If not complete, inform user: "Execution is not complete for this task. You may proceed with partial documentation, or run `/execute TASK_SLUG={{TASK_SLUG}}` first for complete coverage."
+
+2. **Project Context Exists**: Check `{{RRCE_DATA}}/knowledge/project-context.md` exists.
+   - If missing, recommend: "Consider running `/init` first to establish project context for better documentation."
+
+Documentation can proceed even if prerequisites are not fully met, but output quality may be limited.
 
 Mission
 - Translate the implemented work and accumulated context into durable documentation.

package/agent-core/prompts/executor.md

@@ -16,8 +16,28 @@ auto-identity:
 
 You are the Executor for the project. Operate like a senior individual contributor who ships clean, well-tested code aligned with the orchestrated plan.
 
-Prerequisite
-**IMPORTANT**: Before proceeding, verify that `{{RRCE_DATA}}/knowledge/project-context.md` exists. If it does not exist, stop and instruct the user to run `/init` first to establish project context. Do not continue with execution until initialization is complete.
+Pipeline Position
+- **Requires**: Planning phase must be complete before execution can begin.
+- **Next Step**: After execution is complete, optionally hand off to `/docs` (Documentation agent).
+
+Prerequisites (STRICT)
+Before proceeding, verify ALL of the following:
+
+1. **Planning Complete**: Check `{{RRCE_DATA}}/tasks/{{TASK_SLUG}}/meta.json` exists and `agents.planning.status` is `complete`.
+   - If meta.json doesn't exist, **STOP** and prompt user:
+   > "Task not found. Please run `/research TASK_SLUG={{TASK_SLUG}}` to start a new task."
+   - If planning status is not `complete`, **STOP** and prompt user:
+   > "Planning phase is not complete for this task. Please run `/plan TASK_SLUG={{TASK_SLUG}}` first."
+
+2. **Plan Artifact Exists**: Check that the plan file at `{{RRCE_DATA}}/tasks/{{TASK_SLUG}}/planning/{{TASK_SLUG}}-plan.md` exists.
+   - If missing, **STOP** and prompt user:
+   > "Plan artifact not found. Please run `/plan TASK_SLUG={{TASK_SLUG}}` first."
+
+3. **Project Context Exists**: Check `{{RRCE_DATA}}/knowledge/project-context.md` exists.
+   - If missing, **STOP** and prompt user:
+   > "Project context not found. Please run `/init` first to establish project context."
+
+Do not proceed with execution until all prerequisites are satisfied.
 
 Mission
 - Implement the scoped work, keeping quality high and feedback loops short.

package/agent-core/prompts/init.md

@@ -15,6 +15,11 @@ auto-identity:
 
 You are the Project Initializer for RRCE-Workflow. Operate like a senior architect performing a comprehensive codebase audit to establish foundational context for all downstream agents.
 
+Pipeline Position
+- **Entry Point**: Init can be run at any time to establish or update project context.
+- **Correlation**: Init and Planning work together to maintain project context. Planning may trigger Init updates when significant changes are planned.
+- **Foundation**: All other agents (Research, Executor, Documentation, Sync) rely on the `project-context.md` created by Init.
+
 Mission
 - Analyze the workspace to extract tech stack, architecture patterns, coding conventions, and project structure.
 - Produce a durable project context file that informs all future agent interactions.

package/agent-core/prompts/planning_orchestrator.md

@@ -13,8 +13,23 @@ auto-identity:
 
 You are the Planning & Task Orchestrator for the project. Operate like an engineering manager with deep scoped knowledge of this codebase.
 
-Prerequisite
-**IMPORTANT**: Before proceeding, verify that `{{RRCE_DATA}}/knowledge/project-context.md` exists. If it does not exist, stop and instruct the user to run `/init` first to establish project context. Do not continue with planning until initialization is complete.
+Pipeline Position
+- **Requires**: Research phase must be complete before planning can begin.
+- **Correlation**: Planning works with Init to maintain project context. If planning reveals significant architectural changes, recommend running `/init` to update project context.
+- **Next Step**: After planning is complete, hand off to `/execute` (Executor agent).
+
+Prerequisites (STRICT)
+Before proceeding, verify ALL of the following:
+
+1. **Research Complete**: Check `{{RRCE_DATA}}/tasks/{{TASK_SLUG}}/meta.json` exists and `agents.research.status` is `complete`.
+   - If meta.json doesn't exist or research status is not `complete`, **STOP** and prompt user:
+   > "Research phase is not complete for this task. Please run `/research TASK_SLUG={{TASK_SLUG}}` first."
+
+2. **Project Context Exists**: Check `{{RRCE_DATA}}/knowledge/project-context.md` exists.
+   - If missing, **STOP** and prompt user:
+   > "Project context not found. Please run `/init` first to establish project context."
+
+Do not proceed with planning until both prerequisites are satisfied.
 
 Mission
 - Convert the Research brief into a concrete, prioritized plan that the Executor can follow with minimal ambiguity.

package/agent-core/prompts/research_discussion.md

@@ -20,8 +20,10 @@ auto-identity:
 
 You are the Research & Discussion Lead for the project. Operate like a staff-level tech lead who owns broad project awareness.
 
-Prerequisite
-**IMPORTANT**: Before proceeding, verify that `{{RRCE_DATA}}/knowledge/project-context.md` exists. If it does not exist, stop and instruct the user to run `/init` first to establish project context. Do not continue with research until initialization is complete.
+Pipeline Position
+- **Entry Point**: Research can be the first agent invoked for a new task.
+- **Recommendation**: If `{{RRCE_DATA}}/knowledge/project-context.md` does not exist, recommend running `/init` first for best results, but you may proceed with research if the user prefers.
+- **Next Step**: After research is complete, hand off to `/plan` (Planning agent).
 
 Mission
 - Challenge and refine the incoming request until intent, constraints, and success criteria are explicit.

package/agent-core/prompts/sync.md

@@ -14,8 +14,17 @@ auto-identity:
 
 You are the Knowledge Sync Lead. Act like a senior architect charged with keeping the RRCE knowledge cache authoritative and current.
 
-Prerequisite
-**IMPORTANT**: Before proceeding, verify that `{{RRCE_DATA}}/knowledge/project-context.md` exists. If it does not exist, stop and instruct the user to run `/init` first to establish project context. Do not continue with sync until initialization is complete.
+Pipeline Position
+- **Maintenance Agent**: Sync runs periodically or after significant codebase changes to keep knowledge current.
+- **Requires**: Init must have been run at least once (project-context.md must exist).
+- **Triggers Init**: If sync detects major structural changes, recommend running `/init` to update project context.
+
+Prerequisites (STRICT)
+1. **Project Context Exists**: Check `{{RRCE_DATA}}/knowledge/project-context.md` exists.
+   - If missing, **STOP** and prompt user:
+   > "Project context not found. Please run `/init` first to establish project context before syncing."
+
+Do not proceed with sync until the prerequisite is satisfied.
 
 Mission
 - Inspect the live codebase to understand the present implementation and its recent changes.

package/package.json

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

package/src/commands/wizard.ts

@@ -3,7 +3,7 @@ import pc from 'picocolors';
 import * as fs from 'fs';
 import * as path from 'path';
 import { getGitUser } from '../lib/git';
-import { detectWorkspaceRoot, getWorkspaceName, resolveAllDataPaths, ensureDir, getAgentPromptPath, syncMetadataToAll, copyDirToAllStoragePaths, listGlobalProjects, getGlobalProjectKnowledgePath, getRRCEHome } from '../lib/paths';
+import { detectWorkspaceRoot, getWorkspaceName, resolveAllDataPaths, ensureDir, getAgentPromptPath, syncMetadataToAll, copyDirToAllStoragePaths, listGlobalProjects, getGlobalProjectKnowledgePath, getRRCEHome, getGlobalWorkspacePath, getLocalWorkspacePath } from '../lib/paths';
 import type { StorageMode } from '../types/prompt';
 import { loadPromptsFromDir, getAgentCorePromptsDir, getAgentCoreDir } from '../lib/prompts';
 
@@ -34,16 +34,51 @@ Workspace: ${pc.bold(workspaceName)}`,
   // Check if already configured
   const configFilePath = path.join(workspacePath, '.rrce-workflow.yaml');
   const isAlreadyConfigured = fs.existsSync(configFilePath);
+  
+  // Check current storage mode from config
+  let currentStorageMode: string | null = null;
+  if (isAlreadyConfigured) {
+    try {
+      const configContent = fs.readFileSync(configFilePath, 'utf-8');
+      const modeMatch = configContent.match(/mode:\s*(global|workspace|both)/);
+      currentStorageMode = modeMatch?.[1] ?? null;
+    } catch {
+      // Ignore parse errors
+    }
+  }
+
+  // Check if workspace has local data that could be synced
+  const localDataPath = path.join(workspacePath, '.rrce-workflow');
+  const hasLocalData = fs.existsSync(localDataPath);
+
+  // If already configured, show menu
+  if (isAlreadyConfigured) {
+    const menuOptions: { value: string; label: string; hint?: string }[] = [];
+    
+    // Add link option if other projects exist
+    if (existingProjects.length > 0) {
+      menuOptions.push({ 
+        value: 'link', 
+        label: 'Link other project knowledge', 
+        hint: `${existingProjects.length} projects available` 
+      });
+    }
+    
+    // Add sync to global option if using workspace-only mode
+    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' });
 
-  // If already configured and there are other projects, show menu
-  if (isAlreadyConfigured && existingProjects.length > 0) {
     const action = await select({
       message: 'This workspace is already configured. What would you like to do?',
-      options: [
-        { value: 'link', label: 'Link other project knowledge', hint: `${existingProjects.length} projects available` },
-        { value: 'reconfigure', label: 'Reconfigure from scratch' },
-        { value: 'exit', label: 'Exit' },
-      ],
+      options: menuOptions,
     });
 
     if (isCancel(action) || action === 'exit') {
@@ -52,11 +87,19 @@ Workspace: ${pc.bold(workspaceName)}`,
     }
 
     if (action === 'link') {
-      // Link-only flow
       await runLinkProjectsFlow(workspacePath, workspaceName, existingProjects);
       return;
     }
-    // Otherwise continue to full reconfigure flow
+
+    if (action === 'sync-global') {
+      await runSyncToGlobalFlow(workspacePath, workspaceName);
+      return;
+    }
+
+    if (action === 'update') {
+      await runUpdateFlow(workspacePath, workspaceName, currentStorageMode);
+      return;
+    }
   }
 
   // Full setup flow
@@ -215,11 +258,17 @@ tools:
 
     if (linkedProjects.length > 0) {
       summary.push(`Linked projects: ${linkedProjects.join(', ')}`);
+      summary.push(`Workspace file: ${pc.cyan(`${workspaceName}.code-workspace`)}`);
     }
     
     note(summary.join('\n'), 'Setup Summary');
     
-    outro(pc.green(`✓ Setup complete! Your agents are ready to use.`));
+    // Show appropriate outro message
+    if (linkedProjects.length > 0) {
+      outro(pc.green(`✓ Setup complete! Open ${pc.bold(`${workspaceName}.code-workspace`)} in VSCode to access linked knowledge.`));
+    } else {
+      outro(pc.green(`✓ Setup complete! Your agents are ready to use.`));
+    }
 
   } catch (error) {
     s.stop('Error occurred');
@@ -367,14 +416,197 @@ async function runLinkProjectsFlow(workspacePath: string, workspaceName: string,
   s.stop('Projects linked');
 
   // Show summary
+  const workspaceFile = `${workspaceName}.code-workspace`;
   const summary = [
     `Linked projects:`,
     ...selectedProjects.map(p => `  ✓ ${p}`),
     ``,
-    `VSCode workspace file updated: ${workspaceName}.code-workspace`,
+    `Workspace file: ${pc.cyan(workspaceFile)}`,
   ];
 
   note(summary.join('\n'), 'Link Summary');
 
-  outro(pc.green('✓ Projects linked successfully!'));
+  outro(pc.green(`✓ Projects linked! Open ${pc.bold(workspaceFile)} in VSCode to access linked knowledge.`));
+}
+
+/**
+ * Sync workspace knowledge to global storage so other projects can reference it
+ */
+async function runSyncToGlobalFlow(workspacePath: string, workspaceName: string) {
+  const localPath = getLocalWorkspacePath(workspacePath);
+  const globalPath = getGlobalWorkspacePath(workspaceName);
+
+  // Check what exists locally
+  const subdirs = ['knowledge', 'prompts', 'templates', 'tasks', 'refs'];
+  const existingDirs = subdirs.filter(dir => 
+    fs.existsSync(path.join(localPath, dir))
+  );
+
+  if (existingDirs.length === 0) {
+    outro(pc.yellow('No data found in workspace storage to sync.'));
+    return;
+  }
+
+  // Show what will be synced
+  note(
+    `The following will be copied to global storage:\n${existingDirs.map(d => `  • ${d}/`).join('\n')}\n\nDestination: ${pc.cyan(globalPath)}`,
+    'Sync Preview'
+  );
+
+  const shouldSync = await confirm({
+    message: 'Proceed with sync to global storage?',
+    initialValue: true,
+  });
+
+  if (isCancel(shouldSync) || !shouldSync) {
+    outro('Sync cancelled.');
+    return;
+  }
+
+  const s = spinner();
+  s.start('Syncing to global storage');
+
+  try {
+    // Ensure global directory exists
+    ensureDir(globalPath);
+
+    // Copy each directory
+    for (const dir of existingDirs) {
+      const srcDir = path.join(localPath, dir);
+      const destDir = path.join(globalPath, dir);
+      ensureDir(destDir);
+      
+      // Copy files recursively
+      copyDirRecursive(srcDir, destDir);
+    }
+
+    // Update the config to reflect 'both' mode
+    const configFilePath = path.join(workspacePath, '.rrce-workflow.yaml');
+    let configContent = fs.readFileSync(configFilePath, 'utf-8');
+    configContent = configContent.replace(/mode:\s*workspace/, 'mode: both');
+    fs.writeFileSync(configFilePath, configContent);
+
+    s.stop('Sync complete');
+
+    const summary = [
+      `Synced directories:`,
+      ...existingDirs.map(d => `  ✓ ${d}/`),
+      ``,
+      `Global path: ${pc.cyan(globalPath)}`,
+      `Storage mode updated to: ${pc.bold('both')}`,
+      ``,
+      `Other projects can now link this knowledge!`,
+    ];
+
+    note(summary.join('\n'), 'Sync Summary');
+
+    outro(pc.green('✓ Workspace knowledge synced to global storage!'));
+
+  } catch (error) {
+    s.stop('Error occurred');
+    cancel(`Failed to sync: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Recursively copy a directory
+ */
+function copyDirRecursive(src: string, dest: string) {
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    
+    if (entry.isDirectory()) {
+      ensureDir(destPath);
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+/**
+ * Update prompts and templates from the package without resetting config
+ */
+async function runUpdateFlow(workspacePath: string, workspaceName: string, currentStorageMode: string | null) {
+  const s = spinner();
+  s.start('Checking for updates');
+
+  try {
+    const agentCoreDir = getAgentCoreDir();
+    const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
+
+    // Determine storage paths based on current mode
+    const mode = (currentStorageMode as StorageMode) || 'global';
+    const dataPaths = resolveAllDataPaths(mode, workspaceName, workspacePath);
+
+    s.stop('Updates found');
+
+    // Show what will be updated
+    note(
+      `The following will be updated from the package:\n  • prompts/ (${prompts.length} agent prompts)\n  • templates/ (output templates)\n\nTarget locations:\n${dataPaths.map(p => `  • ${p}`).join('\n')}`,
+      'Update Preview'
+    );
+
+    const shouldUpdate = await confirm({
+      message: 'Proceed with update?',
+      initialValue: true,
+    });
+
+    if (isCancel(shouldUpdate) || !shouldUpdate) {
+      outro('Update cancelled.');
+      return;
+    }
+
+    s.start('Updating from package');
+
+    // Update prompts and templates in all storage locations
+    for (const dataPath of dataPaths) {
+      // Update prompts
+      const promptsDir = path.join(dataPath, 'prompts');
+      ensureDir(promptsDir);
+      copyPromptsToDir(prompts, promptsDir, '.md');
+
+      // Update templates
+      copyDirToAllStoragePaths(path.join(agentCoreDir, 'templates'), 'templates', [dataPath]);
+    }
+
+    // Also update tool-specific locations if configured
+    const configFilePath = path.join(workspacePath, '.rrce-workflow.yaml');
+    const configContent = fs.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:`,
+      `  ✓ ${prompts.length} agent prompts`,
+      `  ✓ Output templates`,
+      ``,
+      `Your configuration and knowledge files were preserved.`,
+    ];
+
+    note(summary.join('\n'), 'Update Summary');
+
+    outro(pc.green('✓ Successfully updated from package!'));
+
+  } catch (error) {
+    s.stop('Error occurred');
+    cancel(`Failed to update: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
 }

package/src/lib/paths.ts

@@ -114,6 +114,20 @@ export function getGlobalProjectKnowledgePath(projectName: string): string {
   return path.join(RRCE_HOME, 'workspaces', projectName, 'knowledge');
 }
 
+/**
+ * Get the global workspace data path for a project
+ */
+export function getGlobalWorkspacePath(workspaceName: string): string {
+  return path.join(RRCE_HOME, 'workspaces', workspaceName);
+}
+
+/**
+ * Get the local workspace data path
+ */
+export function getLocalWorkspacePath(workspaceRoot: string): string {
+  return path.join(workspaceRoot, '.rrce-workflow');
+}
+
 /**
  * Ensure directory exists
  */