rrce-workflow 0.1.5 → 0.2.6

package/src/commands/wizard/setup-flow.ts

@@ -0,0 +1,356 @@
+import { group, text, select, multiselect, confirm, spinner, note, outro, cancel, isCancel } from '@clack/prompts';
+import pc from 'picocolors';
+import * as fs from 'fs';
+import * as path from 'path';
+import type { StorageMode } from '../../types/prompt';
+import { 
+  ensureDir, 
+  getAgentPromptPath,
+  syncMetadataToAll,
+  copyDirToAllStoragePaths,
+  checkWriteAccess,
+  getDefaultRRCEHome
+} from '../../lib/paths';
+import { loadPromptsFromDir, getAgentCorePromptsDir, getAgentCoreDir } from '../../lib/prompts';
+import { copyPromptsToDir } from './utils';
+import { generateVSCodeWorkspace } from './vscode';
+
+interface SetupConfig {
+  storageMode: StorageMode;
+  globalPath?: string;
+  tools: string[];
+  linkedProjects: string[];
+}
+
+/**
+ * Run the full setup flow for new workspaces
+ */
+export async function runSetupFlow(
+  workspacePath: string,
+  workspaceName: string,
+  existingProjects: string[]
+): Promise<void> {
+  const s = spinner();
+  
+  // Full setup flow
+  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: () => {
+        // Only show if there are other projects to link
+        if (existingProjects.length === 0) {
+          return Promise.resolve([]);
+        }
+        return multiselect({
+          message: 'Link knowledge from other projects?',
+          options: existingProjects.map(name => ({
+            value: name,
+            label: name,
+            hint: `~/.rrce-workflow/workspaces/${name}/knowledge`
+          })),
+          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);
+  }
+
+  // Determine global path for 'global' or 'both' modes
+  let customGlobalPath: string | undefined;
+  
+  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 as StorageMode,
+      globalPath: customGlobalPath,
+      tools: config.tools as string[],
+      linkedProjects: config.linkedProjects as string[],
+    }, workspacePath, workspaceName);
+
+    s.stop('Configuration generated');
+    
+    // Show summary
+    const dataPaths = getDataPaths(
+      config.storageMode as StorageMode, 
+      workspaceName, 
+      workspacePath,
+      customGlobalPath
+    );
+    
+    const summary = [
+      `Storage: ${config.storageMode === 'both' ? 'global + workspace' : config.storageMode}`,
+    ];
+    
+    if (customGlobalPath && customGlobalPath !== getDefaultRRCEHome()) {
+      summary.push(`Global path: ${pc.cyan(customGlobalPath)}`);
+    }
+    
+    if (dataPaths.length > 0) {
+      summary.push(`Data paths:`);
+      dataPaths.forEach(p => summary.push(`  - ${p}`));
+    }
+    
+    const selectedTools = config.tools as string[];
+    if (selectedTools.length > 0) {
+      summary.push(`Tools: ${selectedTools.join(', ')}`);
+    }
+
+    const linkedProjects = config.linkedProjects as string[];
+    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');
+    
+    // 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');
+    cancel(`Failed to setup: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Resolve global path - always prompt user to choose default or custom
+ */
+async function resolveGlobalPath(): Promise<string | undefined> {
+  const defaultPath = getDefaultRRCEHome();
+  const isDefaultWritable = checkWriteAccess(defaultPath);
+  
+  // Build options
+  const options: { value: string; label: string; hint?: string }[] = [];
+  
+  // Default option
+  options.push({
+    value: 'default',
+    label: `Default (${defaultPath})`,
+    hint: isDefaultWritable ? pc.green('✓ writable') : pc.red('✗ not writable'),
+  });
+  
+  // Custom option
+  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 (isCancel(choice)) {
+    return undefined;
+  }
+
+  if (choice === 'default') {
+    // Verify it's writable
+    if (!isDefaultWritable) {
+      note(
+        `${pc.yellow('⚠')} Cannot write to default path:\n  ${pc.dim(defaultPath)}\n\nThis can happen when running via npx/bunx in restricted environments.\nPlease choose a custom path instead.`,
+        'Write Access Issue'
+      );
+      // Recursively ask again
+      return resolveGlobalPath();
+    }
+    return defaultPath;
+  }
+
+  // Custom path input
+  const customPath = await text({
+    message: 'Enter custom global path:',
+    placeholder: path.join(process.env.HOME || '~', '.local', 'share', 'rrce-workflow'),
+    validate: (value) => {
+      if (!value.trim()) {
+        return 'Path cannot be empty';
+      }
+      // Expand ~ to home directory
+      const expandedPath = value.startsWith('~') 
+        ? value.replace('~', process.env.HOME || '') 
+        : value;
+      
+      if (!checkWriteAccess(expandedPath)) {
+        return `Cannot write to ${expandedPath}. Please choose a writable path.`;
+      }
+      return undefined;
+    },
+  });
+
+  if (isCancel(customPath)) {
+    return undefined;
+  }
+
+  // Expand ~ if present
+  const expandedPath = (customPath as string).startsWith('~')
+    ? (customPath as string).replace('~', process.env.HOME || '')
+    : customPath as string;
+  
+  return expandedPath;
+}
+
+/**
+ * Generate configuration files and directories
+ */
+async function generateConfiguration(
+  config: SetupConfig,
+  workspacePath: string,
+  workspaceName: string
+): Promise<void> {
+  const dataPaths = getDataPaths(config.storageMode, workspaceName, workspacePath, config.globalPath);
+  
+  for (const dataPath of dataPaths) {
+    ensureDir(dataPath);
+    // Create agent metadata subdirectories
+    ensureDir(path.join(dataPath, 'knowledge'));
+    ensureDir(path.join(dataPath, 'refs'));
+    ensureDir(path.join(dataPath, 'tasks'));
+    ensureDir(path.join(dataPath, 'templates'));
+    ensureDir(path.join(dataPath, 'prompts'));
+  }
+
+  // Get the agent-core directory path
+  const agentCoreDir = getAgentCoreDir();
+  
+  // Sync metadata (knowledge, refs, tasks) from agent-core to all storage locations
+  syncMetadataToAll(agentCoreDir, dataPaths);
+  
+  // Also copy templates to all storage locations
+  copyDirToAllStoragePaths(path.join(agentCoreDir, 'templates'), 'templates', dataPaths);
+
+  // Load prompts
+  const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
+
+  // Copy prompts to all storage locations (for cross-project access)
+  for (const dataPath of dataPaths) {
+    const promptsDir = path.join(dataPath, 'prompts');
+    ensureDir(promptsDir);
+    copyPromptsToDir(prompts, promptsDir, '.md');
+  }
+
+  // Copy prompts to tool-specific locations (for IDE integration)
+  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');
+  }
+
+  // Create workspace config (inside .rrce-workflow folder)
+  const workspaceConfigPath = path.join(workspacePath, '.rrce-workflow', 'config.yaml');
+  ensureDir(path.dirname(workspaceConfigPath));
+  
+  let configContent = `# RRCE-Workflow Configuration
+version: 1
+
+storage:
+  mode: ${config.storageMode}`;
+
+  // Add custom global path if different from default
+  if (config.globalPath && config.globalPath !== getDefaultRRCEHome()) {
+    configContent += `\n  globalPath: "${config.globalPath}"`;
+  }
+
+  configContent += `
+
+project:
+  name: "${workspaceName}"
+
+tools:
+  copilot: ${config.tools.includes('copilot')}
+  antigravity: ${config.tools.includes('antigravity')}
+`;
+
+  // Add linked projects if any
+  if (config.linkedProjects.length > 0) {
+    configContent += `\nlinked_projects:\n`;
+    config.linkedProjects.forEach(name => {
+      configContent += `  - ${name}\n`;
+    });
+  }
+
+  fs.writeFileSync(workspaceConfigPath, configContent);
+
+  // Generate VSCode workspace file if using copilot or has linked projects
+  if (config.tools.includes('copilot') || config.linkedProjects.length > 0) {
+    generateVSCodeWorkspace(workspacePath, workspaceName, config.linkedProjects, config.globalPath);
+  }
+}
+
+/**
+ * Get data paths based on storage mode and custom global path
+ */
+function getDataPaths(
+  mode: StorageMode, 
+  workspaceName: string, 
+  workspaceRoot: string,
+  customGlobalPath?: string
+): string[] {
+  const globalPath = path.join(customGlobalPath || getDefaultRRCEHome(), 'workspaces', workspaceName);
+  const workspacePath = path.join(workspaceRoot, '.rrce-workflow');
+  
+  switch (mode) {
+    case 'global':
+      return [globalPath];
+    case 'workspace':
+      return [workspacePath];
+    case 'both':
+      return [workspacePath, globalPath];
+    default:
+      return [globalPath];
+  }
+}

package/src/commands/wizard/sync-flow.ts

@@ -0,0 +1,93 @@
+import { confirm, spinner, note, outro, cancel, isCancel } from '@clack/prompts';
+import pc from 'picocolors';
+import * as fs from 'fs';
+import * as path from 'path';
+import { 
+  ensureDir, 
+  getLocalWorkspacePath, 
+  getGlobalWorkspacePath,
+  getEffectiveRRCEHome,
+  getConfigPath
+} from '../../lib/paths';
+import { copyDirRecursive } from './utils';
+
+/**
+ * Sync workspace knowledge to global storage so other projects can reference it
+ */
+export async function runSyncToGlobalFlow(workspacePath: string, workspaceName: string) {
+  const localPath = getLocalWorkspacePath(workspacePath);
+  const customGlobalPath = getEffectiveRRCEHome(workspacePath);
+  const globalPath = path.join(customGlobalPath, 'workspaces', 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 = getConfigPath(workspacePath);
+    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);
+  }
+}

package/src/commands/wizard/update-flow.ts

@@ -0,0 +1,129 @@
+import { confirm, spinner, note, outro, cancel, isCancel } from '@clack/prompts';
+import pc from 'picocolors';
+import * as fs from 'fs';
+import * as path from 'path';
+import type { StorageMode } from '../../types/prompt';
+import { 
+  ensureDir, 
+  resolveAllDataPaths, 
+  getAgentPromptPath,
+  copyDirToAllStoragePaths,
+  getEffectiveRRCEHome,
+  getConfigPath
+} from '../../lib/paths';
+import { loadPromptsFromDir, getAgentCorePromptsDir, getAgentCoreDir } from '../../lib/prompts';
+import { copyPromptsToDir } from './utils';
+
+/**
+ * Update prompts and templates from the package without resetting config
+ */
+export 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';
+    
+    // Use effective RRCE_HOME from config for path resolution
+    const customGlobalPath = getEffectiveRRCEHome(workspacePath);
+    const dataPaths = resolveAllDataPathsWithCustomGlobal(mode, workspaceName, workspacePath, customGlobalPath);
+
+    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 = getConfigPath(workspacePath);
+    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);
+  }
+}
+
+/**
+ * Resolve all data paths with custom global path support
+ */
+function resolveAllDataPathsWithCustomGlobal(
+  mode: StorageMode, 
+  workspaceName: string, 
+  workspaceRoot: string,
+  customGlobalPath: string
+): string[] {
+  const globalPath = path.join(customGlobalPath, 'workspaces', workspaceName);
+  const workspacePath = path.join(workspaceRoot, '.rrce-workflow');
+  
+  switch (mode) {
+    case 'global':
+      return [globalPath];
+    case 'workspace':
+      return [workspacePath];
+    case 'both':
+      return [workspacePath, globalPath];
+    default:
+      return [globalPath];
+  }
+}

package/src/commands/wizard/utils.ts

@@ -0,0 +1,38 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { ensureDir } from '../../lib/paths';
+import type { ParsedPrompt } from '../../types/prompt';
+
+/**
+ * Copy parsed prompts to a target directory with specified extension
+ */
+export function copyPromptsToDir(prompts: ParsedPrompt[], targetDir: string, extension: string) {
+  for (const prompt of prompts) {
+    const baseName = path.basename(prompt.filePath, '.md');
+    const targetName = baseName + extension;
+    const targetPath = path.join(targetDir, targetName);
+    
+    // Read the full content including frontmatter
+    const content = fs.readFileSync(prompt.filePath, 'utf-8');
+    fs.writeFileSync(targetPath, content);
+  }
+}
+
+/**
+ * Recursively copy a directory
+ */
+export 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);
+    }
+  }
+}

package/src/commands/wizard/vscode.ts

@@ -0,0 +1,66 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { getRRCEHome } from '../../lib/paths';
+
+interface VSCodeWorkspaceFolder {
+  path: string;
+  name?: string;
+}
+
+interface VSCodeWorkspace {
+  folders: VSCodeWorkspaceFolder[];
+  settings?: Record<string, unknown>;
+}
+
+/**
+ * Generate or update VSCode workspace file with linked project knowledge folders
+ */
+export function generateVSCodeWorkspace(
+  workspacePath: string, 
+  workspaceName: string, 
+  linkedProjects: string[],
+  customGlobalPath?: string
+) {
+  const workspaceFilePath = path.join(workspacePath, `${workspaceName}.code-workspace`);
+  
+  let workspace: VSCodeWorkspace;
+  
+  // Check if workspace file already exists
+  if (fs.existsSync(workspaceFilePath)) {
+    try {
+      const content = fs.readFileSync(workspaceFilePath, 'utf-8');
+      workspace = JSON.parse(content);
+    } catch {
+      // If parse fails, create new
+      workspace = { folders: [] };
+    }
+  } else {
+    workspace = { folders: [] };
+  }
+
+  // Ensure main workspace folder is first
+  const mainFolder: VSCodeWorkspaceFolder = { path: '.' };
+  const existingMainIndex = workspace.folders.findIndex(f => f.path === '.');
+  if (existingMainIndex === -1) {
+    workspace.folders.unshift(mainFolder);
+  }
+
+  // Add linked project knowledge folders
+  const rrceHome = customGlobalPath || getRRCEHome();
+  for (const projectName of linkedProjects) {
+    const knowledgePath = path.join(rrceHome, 'workspaces', projectName, 'knowledge');
+    const folderEntry: VSCodeWorkspaceFolder = {
+      path: knowledgePath,
+      name: `📚 ${projectName} (knowledge)`
+    };
+
+    // Check if already exists
+    const existingIndex = workspace.folders.findIndex(f => f.path === knowledgePath);
+    if (existingIndex === -1) {
+      workspace.folders.push(folderEntry);
+    }
+  }
+
+  // Write workspace file
+  fs.writeFileSync(workspaceFilePath, JSON.stringify(workspace, null, 2));
+}

package/src/index.ts

@@ -1,4 +1,4 @@
-import { runWizard } from './commands/wizard';
+import { runWizard } from './commands/wizard/index';
 import { runSelector } from './commands/selector';
 
 // Get command from args