rrce-workflow 0.2.14 → 0.2.15

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

@@ -1,118 +0,0 @@
-import { multiselect, spinner, note, outro, cancel, isCancel } from '@clack/prompts';
-import pc from 'picocolors';
-import * as fs from 'fs';
-import { getEffectiveRRCEHome, getConfigPath } from '../../lib/paths';
-import { generateVSCodeWorkspace } from './vscode';
-import { scanForProjects, getProjectDisplayLabel, type DetectedProject } from '../../lib/detection';
-
-/**
- * Run the link-only flow for adding other project knowledge to an existing workspace
- * Now supports detecting workspace-scoped sibling projects, not just global storage
- */
-export async function runLinkProjectsFlow(
-  workspacePath: string, 
-  workspaceName: string, 
-  existingProjects?: string[]
-) {
-  // Scan for projects using the new detection system
-  const detectedProjects = scanForProjects({
-    excludeWorkspace: workspaceName,
-    workspacePath: workspacePath,
-    scanSiblings: true,
-  });
-  
-  // If legacy string array is passed, use that instead (for backwards compat)
-  const projects = existingProjects 
-    ? existingProjects.map(name => ({ name, source: 'global' as const } as DetectedProject))
-    : detectedProjects;
-  
-  if (projects.length === 0) {
-    outro(pc.yellow('No other projects found. Try setting up another project first.'));
-    return;
-  }
-
-  const customGlobalPath = getEffectiveRRCEHome(workspacePath);
-  
-  // Build options with source labels
-  const linkedProjects = await multiselect({
-    message: 'Select projects to link:',
-    options: projects.map(project => ({
-      value: project.name,
-      label: project.name,
-      hint: pc.dim(getProjectDisplayLabel(project)),
-    })),
-    required: true,
-  });
-
-  if (isCancel(linkedProjects)) {
-    cancel('Cancelled.');
-    process.exit(0);
-  }
-
-  const selectedProjectNames = linkedProjects as string[];
-
-  if (selectedProjectNames.length === 0) {
-    outro('No projects selected.');
-    return;
-  }
-
-  // Get the full DetectedProject objects for selected projects
-  const selectedProjects = projects.filter(p => selectedProjectNames.includes(p.name));
-
-  const s = spinner();
-  s.start('Linking projects');
-
-  // Update config.yaml with linked projects
-  const configFilePath = getConfigPath(workspacePath);
-  let configContent = fs.readFileSync(configFilePath, 'utf-8');
-
-  // Check if linked_projects section exists
-  if (configContent.includes('linked_projects:')) {
-    // Append to existing section - find and update
-    const lines = configContent.split('\n');
-    const linkedIndex = lines.findIndex(l => l.trim() === 'linked_projects:');
-    if (linkedIndex !== -1) {
-      // Find where to insert new projects (after existing ones)
-      let insertIndex = linkedIndex + 1;
-      while (insertIndex < lines.length && lines[insertIndex]?.startsWith('  - ')) {
-        insertIndex++;
-      }
-      // Add new projects that aren't already there
-      for (const name of selectedProjectNames) {
-        if (!configContent.includes(`  - ${name}`)) {
-          lines.splice(insertIndex, 0, `  - ${name}`);
-          insertIndex++;
-        }
-      }
-      configContent = lines.join('\n');
-    }
-  } else {
-    // Add new linked_projects section
-    configContent += `\nlinked_projects:\n`;
-    selectedProjectNames.forEach(name => {
-      configContent += `  - ${name}\n`;
-    });
-  }
-
-  fs.writeFileSync(configFilePath, configContent);
-
-  // Update VSCode workspace file with full project info (includes refs, tasks)
-  generateVSCodeWorkspace(workspacePath, workspaceName, selectedProjects, customGlobalPath);
-
-  s.stop('Projects linked');
-
-  // Show summary with project sources
-  const workspaceFile = `${workspaceName}.code-workspace`;
-  const summary = [
-    `Linked projects:`,
-    ...selectedProjects.map(p => `  ✓ ${p.name} ${pc.dim(`(${p.source})`)}`),
-    ``,
-    `Workspace file: ${pc.cyan(workspaceFile)}`,
-    ``,
-    pc.dim('Includes: knowledge, refs, tasks folders'),
-  ];
-
-  note(summary.join('\n'), 'Link Summary');
-
-  outro(pc.green(`✓ Projects linked! Open ${pc.bold(workspaceFile)} in VSCode to access linked knowledge.`));
-}

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

@@ -1,347 +0,0 @@
-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';
-import { directoryAutocomplete, isCancel as isAutocompleteCancel } from '../../lib/autocomplete-prompt';
-
-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 with Tab autocomplete
-  const suggestedPath = path.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';
-      }
-      // 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 (isAutocompleteCancel(customPath)) {
-    return undefined;
-  }
-
-  // Path is already expanded by directoryAutocomplete
-  return customPath as string;
-}
-
-/**
- * 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 (data only, no prompts)
-    ensureDir(path.join(dataPath, 'knowledge'));
-    ensureDir(path.join(dataPath, 'refs'));
-    ensureDir(path.join(dataPath, 'tasks'));
-    ensureDir(path.join(dataPath, 'templates'));
-  }
-
-  // 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 for IDE-specific locations
-  const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
-
-  // 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

@@ -1,93 +0,0 @@
-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

@@ -1,124 +0,0 @@
-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 templates in all storage locations (no prompts in data paths)
-    for (const dataPath of dataPaths) {
-      // Update templates only
-      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];
-  }
-}