rrce-workflow 0.2.14 → 0.2.16

package/src/commands/wizard/utils.ts

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

@@ -1,197 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { getRRCEHome } from '../../lib/paths';
-import { type DetectedProject, getProjectFolders } from '../../lib/detection';
-
-interface VSCodeWorkspaceFolder {
-  path: string;
-  name?: string;
-}
-
-interface VSCodeWorkspace {
-  folders: VSCodeWorkspaceFolder[];
-  settings?: Record<string, unknown>;
-}
-
-// Reference folder group prefix - used to visually group linked folders
-const REFERENCE_GROUP_PREFIX = '📁 References';
-
-/**
- * Generate or update VSCode workspace file with linked project folders
- * 
- * Features:
- * - Main workspace is clearly marked as the primary project
- * - Linked folders are grouped under a "References" section (via naming)
- * - Folders are organized by project with icons for type (📚 📎 📋)
- * - Reference folders are marked as readonly in workspace settings
- */
-export function generateVSCodeWorkspace(
-  workspacePath: string, 
-  workspaceName: string, 
-  linkedProjects: string[] | DetectedProject[],
-  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: [], settings: {} };
-    }
-  } else {
-    workspace = { folders: [], settings: {} };
-  }
-
-  // Initialize settings if not present
-  if (!workspace.settings) {
-    workspace.settings = {};
-  }
-
-  // Clear existing folders and rebuild (to ensure proper ordering)
-  const existingNonReferencesFolders = workspace.folders.filter(f => 
-    f.path === '.' || (!f.name?.includes(REFERENCE_GROUP_PREFIX) && !f.name?.startsWith('📚') && !f.name?.startsWith('📎') && !f.name?.startsWith('📋'))
-  );
-  
-  workspace.folders = [];
-
-  // 1. Add main workspace folder first with clear label
-  const mainFolder: VSCodeWorkspaceFolder = { 
-    path: '.', 
-    name: `🏠 ${workspaceName} (workspace)` 
-  };
-  workspace.folders.push(mainFolder);
-
-  // 2. Add any other existing non-references folders
-  for (const folder of existingNonReferencesFolders) {
-    if (folder.path !== '.') {
-      workspace.folders.push(folder);
-    }
-  }
-
-  // 3. Add reference folders grouped by project
-  const referenceFolderPaths: string[] = [];
-  
-  // Determine if we're working with DetectedProject[] or string[]
-  const isDetectedProjects = linkedProjects.length > 0 && typeof linkedProjects[0] === 'object';
-
-  if (isDetectedProjects) {
-    // New behavior: use DetectedProject[] with knowledge, refs, tasks folders
-    const projects = linkedProjects as DetectedProject[];
-    
-    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);
-        
-        // Check if already exists
-        const existingIndex = workspace.folders.findIndex(f => f.path === folder.path);
-        if (existingIndex === -1) {
-          workspace.folders.push({
-            path: folder.path,
-            name: `${folder.displayName} [${sourceLabel}]`,
-          });
-        }
-      }
-    }
-  } else {
-    // Legacy behavior: string[] of project names (global storage only)
-    const projectNames = linkedProjects as string[];
-    const rrceHome = customGlobalPath || getRRCEHome();
-    
-    for (const projectName of projectNames) {
-      const projectDataPath = path.join(rrceHome, 'workspaces', projectName);
-      
-      const folderTypes = [
-        { subpath: 'knowledge', icon: '📚', type: 'knowledge' },
-        { subpath: 'refs', icon: '📎', type: 'refs' },
-        { subpath: 'tasks', icon: '📋', type: 'tasks' },
-      ];
-      
-      for (const { subpath, icon, type } of folderTypes) {
-        const folderPath = path.join(projectDataPath, subpath);
-        if (fs.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]`,
-            });
-          }
-        }
-      }
-    }
-  }
-
-  // 4. Add workspace settings to mark reference folders as readonly
-  // This uses files.readonlyInclude to make imported folders read-only
-  if (referenceFolderPaths.length > 0) {
-    const readonlyPatterns: Record<string, boolean> = {};
-    
-    for (const folderPath of referenceFolderPaths) {
-      // Create a pattern that matches all files in this folder
-      readonlyPatterns[`${folderPath}/**`] = true;
-    }
-    
-    // Merge with existing readonly patterns
-    const existingReadonly = (workspace.settings['files.readonlyInclude'] as Record<string, boolean>) || {};
-    workspace.settings['files.readonlyInclude'] = {
-      ...existingReadonly,
-      ...readonlyPatterns,
-    };
-  }
-
-  // 5. Add helpful workspace settings for multi-root experience
-  workspace.settings['explorer.sortOrder'] = workspace.settings['explorer.sortOrder'] || 'default';
-  
-  // Write workspace file with nice formatting
-  fs.writeFileSync(workspaceFilePath, JSON.stringify(workspace, null, 2));
-}
-
-/**
- * Remove a project's folders from the workspace file
- */
-export function removeProjectFromWorkspace(
-  workspacePath: string,
-  workspaceName: string,
-  projectName: string
-) {
-  const workspaceFilePath = path.join(workspacePath, `${workspaceName}.code-workspace`);
-  
-  if (!fs.existsSync(workspaceFilePath)) {
-    return;
-  }
-
-  try {
-    const content = fs.readFileSync(workspaceFilePath, 'utf-8');
-    const workspace: VSCodeWorkspace = JSON.parse(content);
-    
-    // Filter out folders that match the project name
-    workspace.folders = workspace.folders.filter(f => 
-      !f.name?.includes(projectName)
-    );
-    
-    // Also remove readonly patterns for this project
-    if (workspace.settings?.['files.readonlyInclude']) {
-      const readonly = workspace.settings['files.readonlyInclude'] as Record<string, boolean>;
-      for (const pattern of Object.keys(readonly)) {
-        if (pattern.includes(projectName)) {
-          delete readonly[pattern];
-        }
-      }
-    }
-    
-    fs.writeFileSync(workspaceFilePath, JSON.stringify(workspace, null, 2));
-  } catch {
-    // Ignore errors
-  }
-}

package/src/index.ts

@@ -1,11 +0,0 @@
-import { runWizard } from './commands/wizard/index';
-import { runSelector } from './commands/selector';
-
-// Get command from args
-const command = process.argv[2];
-
-if (!command || command === 'wizard') {
-  runWizard();
-} else {
-  runSelector();
-}

package/src/lib/autocomplete-prompt.ts

@@ -1,190 +0,0 @@
-import { TextPrompt, isCancel, type Prompt } from '@clack/core';
-import * as fs from 'fs';
-import * as path from 'path';
-import pc from 'picocolors';
-
-interface DirectoryAutocompleteOptions {
-  message: string;
-  placeholder?: string;
-  initialValue?: string;
-  validate?: (value: string) => string | undefined;
-  hint?: string;
-}
-
-/**
- * Custom text input with Tab-completion for directory paths
- * Uses @clack/core TextPrompt with custom key handling
- */
-export async function directoryAutocomplete(opts: DirectoryAutocompleteOptions): Promise<string | symbol> {
-  let completions: string[] = [];
-  let completionIndex = 0;
-  let lastTabValue = '';
-
-  const prompt = new TextPrompt({
-    initialValue: opts.initialValue,
-    validate: opts.validate,
-    render() {
-      const title = `${pc.cyan('◆')}  ${opts.message}`;
-      const hintText = opts.hint ? pc.dim(` (${opts.hint})`) : '';
-      
-      let inputLine: string;
-      if (this.state === 'error') {
-        inputLine = `${pc.yellow('▲')}  ${this.valueWithCursor}`;
-      } else if (this.state === 'submit') {
-        inputLine = `${pc.green('✓')}  ${pc.dim(String(this.value || ''))}`;
-      } else {
-        inputLine = `${pc.cyan('│')}  ${this.valueWithCursor || pc.dim(opts.placeholder || '')}`;
-      }
-      
-      let result = `${title}${hintText}\n${inputLine}`;
-      
-      if (this.state === 'error' && this.error) {
-        result += `\n${pc.yellow('│')}  ${pc.yellow(this.error)}`;
-      }
-      
-      // Show completion hint if multiple options
-      if (completions.length > 1 && this.state === 'active') {
-        const remaining = completions.length - 1;
-        result += `\n${pc.dim('│')}  ${pc.dim(`+${remaining} more, press Tab again to cycle`)}`;
-      }
-      
-      return result;
-    },
-  });
-
-  // Listen for key events - Tab key handling
-  prompt.on('key', (key) => {
-    if (key === '\t' || key === 'tab') {
-      handleTabCompletion(prompt);
-    } else {
-      // Reset completion state on any other key
-      completions = [];
-      completionIndex = 0;
-      lastTabValue = '';
-    }
-  });
-
-  function handleTabCompletion(p: TextPrompt) {
-    const input = String(p.value || '');
-    
-    // Expand ~ to home directory
-    const expanded = input.startsWith('~')
-      ? input.replace(/^~/, process.env.HOME || '')
-      : input;
-
-    // If user hasn't changed input since last tab, cycle through completions
-    if (lastTabValue === input && completions.length > 1) {
-      completionIndex = (completionIndex + 1) % completions.length;
-      const completion = completions[completionIndex] || '';
-      setPromptValue(p, completion);
-      return;
-    }
-
-    // Get new completions
-    completions = getDirectoryCompletions(expanded);
-    completionIndex = 0;
-    lastTabValue = input;
-
-    if (completions.length === 1) {
-      // Single match - auto-complete with trailing slash if directory
-      const completion = completions[0] || '';
-      setPromptValue(p, completion.endsWith('/') ? completion : completion + '/');
-      completions = []; // Clear so next Tab gets fresh completions
-      lastTabValue = '';
-    } else if (completions.length > 1) {
-      // Multiple matches - complete common prefix and show first
-      const commonPrefix = getCommonPrefix(completions);
-      if (commonPrefix.length > expanded.length) {
-        setPromptValue(p, commonPrefix);
-        lastTabValue = formatForDisplay(commonPrefix);
-      } else {
-        // Show first completion
-        setPromptValue(p, completions[0] || '');
-      }
-    }
-  }
-
-  function setPromptValue(p: TextPrompt, value: string) {
-    // Convert back to ~ format if in home directory for display
-    const displayValue = formatForDisplay(value);
-    
-    // Update the prompt's value by emitting a value event
-    // This is a workaround since TextPrompt doesn't expose a direct setValue method
-    (p as any).value = displayValue;
-  }
-
-  function formatForDisplay(value: string): string {
-    const home = process.env.HOME || '';
-    return value.startsWith(home)
-      ? value.replace(home, '~')
-      : value;
-  }
-
-  function getDirectoryCompletions(inputPath: string): string[] {
-    try {
-      let dirToScan: string;
-      let prefix: string;
-
-      if (inputPath === '' || inputPath === '/') {
-        dirToScan = inputPath || '/';
-        prefix = '';
-      } else if (inputPath.endsWith('/')) {
-        // User typed a complete directory path
-        dirToScan = inputPath;
-        prefix = '';
-      } else {
-        // User is typing a partial name
-        dirToScan = path.dirname(inputPath);
-        prefix = path.basename(inputPath).toLowerCase();
-      }
-
-      if (!fs.existsSync(dirToScan)) {
-        return [];
-      }
-
-      const entries = fs.readdirSync(dirToScan, { withFileTypes: true })
-        .filter(entry => {
-          // Only directories
-          if (!entry.isDirectory()) return false;
-          // Skip hidden directories unless explicitly typing them
-          if (entry.name.startsWith('.') && !prefix.startsWith('.')) return false;
-          // Match prefix
-          return prefix === '' || entry.name.toLowerCase().startsWith(prefix);
-        })
-        .map(entry => path.join(dirToScan, entry.name))
-        .sort();
-
-      return entries;
-    } catch {
-      return [];
-    }
-  }
-
-  function getCommonPrefix(strings: string[]): string {
-    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;
-  }
-  
-  // Expand ~ in final result
-  const value = String(result || '');
-  return value.startsWith('~')
-    ? value.replace(/^~/, process.env.HOME || '')
-    : value;
-}
-
-export { isCancel };

package/src/lib/detection.ts

@@ -1,235 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import type { StorageMode } from '../types/prompt';
-import { getDefaultRRCEHome } from './paths';
-
-/**
- * Detected rrce-workflow project information
- */
-export interface DetectedProject {
-  name: string;
-  path: string;           // Absolute path to project root
-  dataPath: string;       // Path to .rrce-workflow data directory
-  source: 'global' | 'sibling' | 'parent';
-  storageMode?: StorageMode;
-  knowledgePath?: string;
-  refsPath?: string;
-  tasksPath?: string;
-}
-
-interface ScanOptions {
-  excludeWorkspace?: string;  // Current workspace name to exclude
-  workspacePath?: string;     // Current workspace path for sibling detection
-  scanSiblings?: boolean;     // Whether to scan sibling directories (default: true)
-}
-
-/**
- * Scan for rrce-workflow projects in various locations
- */
-export function scanForProjects(options: ScanOptions = {}): DetectedProject[] {
-  const { excludeWorkspace, workspacePath, scanSiblings = true } = options;
-  const projects: DetectedProject[] = [];
-  const seenPaths = new Set<string>();
-
-  // 1. Scan global storage (~/.rrce-workflow/workspaces/)
-  const globalProjects = scanGlobalStorage(excludeWorkspace);
-  for (const project of globalProjects) {
-    if (!seenPaths.has(project.path)) {
-      seenPaths.add(project.path);
-      projects.push(project);
-    }
-  }
-
-  // 2. Scan sibling directories (same parent as current workspace)
-  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;
-}
-
-/**
- * Scan global storage for projects
- */
-function scanGlobalStorage(excludeWorkspace?: string): DetectedProject[] {
-  const rrceHome = getDefaultRRCEHome();
-  const workspacesDir = path.join(rrceHome, 'workspaces');
-  const projects: DetectedProject[] = [];
-
-  if (!fs.existsSync(workspacesDir)) {
-    return projects;
-  }
-
-  try {
-    const entries = fs.readdirSync(workspacesDir, { withFileTypes: true });
-    
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      if (entry.name === excludeWorkspace) continue;
-
-      const projectDataPath = path.join(workspacesDir, entry.name);
-      const knowledgePath = path.join(projectDataPath, 'knowledge');
-      const refsPath = path.join(projectDataPath, 'refs');
-      const tasksPath = path.join(projectDataPath, 'tasks');
-
-      projects.push({
-        name: entry.name,
-        path: projectDataPath,  // For global projects, path is the data path
-        dataPath: projectDataPath,
-        source: 'global',
-        knowledgePath: fs.existsSync(knowledgePath) ? knowledgePath : undefined,
-        refsPath: fs.existsSync(refsPath) ? refsPath : undefined,
-        tasksPath: fs.existsSync(tasksPath) ? tasksPath : undefined,
-      });
-    }
-  } catch {
-    // Ignore errors
-  }
-
-  return projects;
-}
-
-/**
- * Scan sibling directories for workspace-scoped projects
- */
-function scanSiblingDirectories(workspacePath: string, excludeWorkspace?: string): DetectedProject[] {
-  const parentDir = path.dirname(workspacePath);
-  const projects: DetectedProject[] = [];
-
-  try {
-    const entries = fs.readdirSync(parentDir, { withFileTypes: true });
-    
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      
-      const projectPath = path.join(parentDir, entry.name);
-      
-      // Skip current workspace
-      if (projectPath === workspacePath) continue;
-      if (entry.name === excludeWorkspace) continue;
-
-      // Check for .rrce-workflow/config.yaml
-      const configPath = path.join(projectPath, '.rrce-workflow', 'config.yaml');
-      if (!fs.existsSync(configPath)) continue;
-
-      // Parse config to get project details
-      const config = parseWorkspaceConfig(configPath);
-      if (!config) continue;
-
-      const dataPath = path.join(projectPath, '.rrce-workflow');
-      const knowledgePath = path.join(dataPath, 'knowledge');
-      const refsPath = path.join(dataPath, 'refs');
-      const tasksPath = path.join(dataPath, 'tasks');
-
-      projects.push({
-        name: config.name || entry.name,
-        path: projectPath,
-        dataPath,
-        source: 'sibling',
-        storageMode: config.storageMode,
-        knowledgePath: fs.existsSync(knowledgePath) ? knowledgePath : undefined,
-        refsPath: fs.existsSync(refsPath) ? refsPath : undefined,
-        tasksPath: fs.existsSync(tasksPath) ? tasksPath : undefined,
-      });
-    }
-  } catch {
-    // Ignore errors
-  }
-
-  return projects;
-}
-
-/**
- * Parse a workspace config file
- */
-export function parseWorkspaceConfig(configPath: string): {
-  name: string;
-  storageMode: StorageMode;
-  linkedProjects?: string[];
-} | null {
-  try {
-    const content = fs.readFileSync(configPath, 'utf-8');
-    
-    // Simple YAML parsing (we don't want to add a full YAML library)
-    const nameMatch = content.match(/name:\s*["']?([^"'\n]+)["']?/);
-    const modeMatch = content.match(/mode:\s*(global|workspace|both)/);
-    
-    // Parse linked projects
-    const linkedProjects: string[] = [];
-    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() || path.basename(path.dirname(path.dirname(configPath))),
-      storageMode: (modeMatch?.[1] as StorageMode) || 'global',
-      linkedProjects: linkedProjects.length > 0 ? linkedProjects : undefined,
-    };
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Get display label for a detected project
- */
-export function getProjectDisplayLabel(project: DetectedProject): string {
-  switch (project.source) {
-    case 'global':
-      return `global: ~/.rrce-workflow/workspaces/${project.name}`;
-    case 'sibling':
-      return `sibling: ${project.path}/.rrce-workflow`;
-    default:
-      return project.dataPath;
-  }
-}
-
-/**
- * Get all linkable folders from a detected project
- */
-export function getProjectFolders(project: DetectedProject): Array<{
-  path: string;
-  type: 'knowledge' | 'refs' | 'tasks';
-  displayName: string;
-}> {
-  const folders: Array<{ path: string; type: 'knowledge' | 'refs' | 'tasks'; displayName: string }> = [];
-
-  if (project.knowledgePath) {
-    folders.push({
-      path: project.knowledgePath,
-      type: 'knowledge',
-      displayName: `📚 ${project.name} (knowledge)`,
-    });
-  }
-
-  if (project.refsPath) {
-    folders.push({
-      path: project.refsPath,
-      type: 'refs',
-      displayName: `📎 ${project.name} (refs)`,
-    });
-  }
-
-  if (project.tasksPath) {
-    folders.push({
-      path: project.tasksPath,
-      type: 'tasks',
-      displayName: `📋 ${project.name} (tasks)`,
-    });
-  }
-
-  return folders;
-}