rrce-workflow 0.3.12 → 0.3.14

package/docs/AI_AGENT_GUIDE.md

@@ -0,0 +1,65 @@
+# AI Agent Architecture Guide: RRCE-Workflow
+
+This guide helps AI coding agents understand the codebase structure and conventions to ensure accurate implementations and prevent duplication.
+
+## 1. Project Navigation
+
+### Core Directories
+- `src/mcp/`: MCP Server implementation and TUI
+  - `ui/`: React (Ink) components for the TUI
+  - `handlers/`: MCP protocol handlers (tools, prompts, resources)
+  - `services/`: Business logic (RAG, Indexing, Context Extraction)
+  - `lib/`: TUI-specific utilities
+- `src/lib/`: Shared core utilities (detection, paths, project utils)
+- `agent-core/`: Global agent prompts and templates
+- `docs/`: System documentation
+
+### Feature-to-File Mapping
+| Feature | File(s) |
+|---------|---------|
+| TUI Dashboard | `src/mcp/ui/Overview.tsx` |
+| Projects Management | `src/mcp/ui/ProjectsView.tsx` |
+| Task Browser | `src/mcp/ui/TasksView.tsx` |
+| MCP Tools | `src/mcp/handlers/tools.ts` |
+| MCP Resources | `src/mcp/resources.ts` |
+| RAG Logic | `src/mcp/services/rag.ts` |
+| Indexing Background Jobs | `src/mcp/services/indexing-jobs.ts` |
+| Installation Logic | `src/mcp/install.ts` |
+
+## 2. Coding Conventions
+
+### Single Source of Truth (SSOT)
+Always use existing utilities instead of reimplementing logic:
+- **Project Sorting**: Use `sortProjects` from `src/lib/project-utils.ts`.
+- **Project Config Lookup**: Use `findProjectConfig` from `src/mcp/config-utils.ts`.
+- **Path Resolution**: Use `resolveDataPath` or `resolveProjectPaths`.
+
+### TUI Components
+- **Size Limit**: Keep components under 200 lines. Extract sub-components to `src/mcp/ui/components/`.
+- **Styling**: Use `ink` components. Follow the "Unified Cockpit" aesthetic (white borders).
+- **Status Icons**: Use helpers in `src/mcp/ui/ui-helpers.ts`.
+
+### Type Safety
+- **Avoid `any`**: Use `TaskMeta`, `AgentInfo`, and `DetectedProject` types.
+- **Interfaces**: Define clear interfaces for component props and service parameters.
+- **Validation**: Validate input at the boundaries of the MCP tools and resources.
+
+## 3. Implementation Patterns
+
+### Error Handling
+- Never use empty `catch {}` blocks.
+- Use `logger.error(message, error)` for internal logging.
+- Surface meaningful error messages to the user in the TUI via `errorLine` state.
+
+### Async Operations
+- Use `indexingJobs` for long-running background tasks.
+- Ensure the TUI remains responsive by using cooperative yields (`setImmediate`) in tight loops.
+
+### Metadata
+- Task metadata is stored in `meta.json` within project task directories.
+- Use `updateTask` in `resources.ts` to persist changes to task state.
+
+## 4. Common Pitfalls to Avoid
+- **Duplicating Install Logic**: All IDE configurations are handled in `install.ts` using a data-driven approach via `TARGET_CONFIGS`.
+- **Hardcoding Paths**: Always use path resolution utilities to handle Global vs. Workspace modes.
+- **Stale Context**: When searching code, be aware that semantic search results might be stale if indexing is in progress. Check the `indexingInProgress` flag.

package/package.json

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

package/dist/commands/selector.d.ts

@@ -1 +0,0 @@
-export declare function runSelector(): Promise<void>;

package/dist/commands/selector.js

@@ -1,29 +0,0 @@
-import { intro, select, note, cancel, isCancel, outro } from '@clack/prompts';
-import pc from 'picocolors';
-import * as path from 'path';
-import { loadPromptsFromDir, getAgentCorePromptsDir } from '../lib/prompts';
-export async function runSelector() {
-    const workspaceName = path.basename(process.cwd());
-    intro(pc.cyan(pc.inverse(` RRCE-Workflow | ${workspaceName} `)));
-    const prompts = loadPromptsFromDir(getAgentCorePromptsDir());
-    if (prompts.length === 0) {
-        cancel('No agents found. Run `rrce-workflow` to set up.');
-        process.exit(0);
-    }
-    const selection = await select({
-        message: 'Select an agent:',
-        options: prompts.map(p => ({
-            value: p,
-            label: p.frontmatter.name,
-            hint: p.frontmatter.description
-        })),
-    });
-    if (isCancel(selection)) {
-        cancel('Selection cancelled.');
-        process.exit(0);
-    }
-    const prompt = selection;
-    note(`Use this agent in your IDE by invoking:
-${pc.bold(pc.cyan(`@${prompt.frontmatter.name}`))}`, 'Agent Selected');
-    outro('Done');
-}

package/dist/commands/wizard/index.d.ts

@@ -1 +0,0 @@
-export declare function runWizard(): Promise<void>;

package/dist/commands/wizard/index.js

@@ -1,86 +0,0 @@
-import { intro, select, spinner, note, outro, isCancel } from '@clack/prompts';
-import pc from 'picocolors';
-import * as fs from 'fs';
-import { getGitUser } from '../../lib/git';
-import { detectWorkspaceRoot, getWorkspaceName, listGlobalProjects, getLocalWorkspacePath, getConfigPath } from '../../lib/paths';
-// Import flows
-import { runSetupFlow } from './setup-flow';
-import { runLinkProjectsFlow } from './link-flow';
-import { runSyncToGlobalFlow } from './sync-flow';
-import { runUpdateFlow } from './update-flow';
-export async function runWizard() {
-    intro(pc.cyan(pc.inverse(' RRCE-Workflow Setup ')));
-    const s = spinner();
-    s.start('Detecting environment');
-    const workspacePath = detectWorkspaceRoot();
-    const workspaceName = getWorkspaceName(workspacePath);
-    const gitUser = getGitUser();
-    await new Promise(r => setTimeout(r, 800)); // Dramatic pause
-    s.stop('Environment detected');
-    note(`Git User:  ${pc.bold(gitUser || '(not found)')}
-Workspace: ${pc.bold(workspaceName)}`, 'Context');
-    // Check for existing projects in global storage
-    const existingProjects = listGlobalProjects(workspaceName);
-    // Check if already configured (using getConfigPath for new/legacy support)
-    const configFilePath = getConfigPath(workspacePath);
-    const isAlreadyConfigured = fs.existsSync(configFilePath);
-    // Check current storage mode from config
-    let currentStorageMode = 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 = getLocalWorkspacePath(workspacePath);
-    const hasLocalData = fs.existsSync(localDataPath);
-    // If already configured, show menu
-    if (isAlreadyConfigured) {
-        const menuOptions = [];
-        // 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' });
-        const action = await select({
-            message: 'This workspace is already configured. What would you like to do?',
-            options: menuOptions,
-        });
-        if (isCancel(action) || action === 'exit') {
-            outro('Exited.');
-            process.exit(0);
-        }
-        if (action === 'link') {
-            await runLinkProjectsFlow(workspacePath, workspaceName, existingProjects);
-            return;
-        }
-        if (action === 'sync-global') {
-            await runSyncToGlobalFlow(workspacePath, workspaceName);
-            return;
-        }
-        if (action === 'update') {
-            await runUpdateFlow(workspacePath, workspaceName, currentStorageMode);
-            return;
-        }
-    }
-    // Run full setup flow for new workspaces
-    await runSetupFlow(workspacePath, workspaceName, existingProjects);
-}

package/dist/commands/wizard/link-flow.d.ts

@@ -1,5 +0,0 @@
-/**
- * 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 declare function runLinkProjectsFlow(workspacePath: string, workspaceName: string, existingProjects?: string[]): Promise<void>;

package/dist/commands/wizard/link-flow.js

@@ -1,97 +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 } 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, workspaceName, existingProjects) {
-    // 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' }))
-        : 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;
-    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/dist/commands/wizard/setup-flow.d.ts

@@ -1,4 +0,0 @@
-/**
- * Run the full setup flow for new workspaces
- */
-export declare function runSetupFlow(workspacePath: string, workspaceName: string, existingProjects: string[]): Promise<void>;

package/dist/commands/wizard/setup-flow.js

@@ -1,262 +0,0 @@
-import { group, 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 { 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';
-/**
- * Run the full setup flow for new workspaces
- */
-export async function runSetupFlow(workspacePath, workspaceName, existingProjects) {
-    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;
-    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,
-            globalPath: customGlobalPath,
-            tools: config.tools,
-            linkedProjects: config.linkedProjects,
-        }, workspacePath, workspaceName);
-        s.stop('Configuration generated');
-        // Show summary
-        const dataPaths = getDataPaths(config.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;
-        if (selectedTools.length > 0) {
-            summary.push(`Tools: ${selectedTools.join(', ')}`);
-        }
-        const linkedProjects = config.linkedProjects;
-        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() {
-    const defaultPath = getDefaultRRCEHome();
-    const isDefaultWritable = checkWriteAccess(defaultPath);
-    // Build options
-    const options = [];
-    // 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;
-}
-/**
- * Generate configuration files and directories
- */
-async function generateConfiguration(config, workspacePath, workspaceName) {
-    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, workspaceName, workspaceRoot, customGlobalPath) {
-    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/dist/commands/wizard/sync-flow.d.ts

@@ -1,4 +0,0 @@
-/**
- * Sync workspace knowledge to global storage so other projects can reference it
- */
-export declare function runSyncToGlobalFlow(workspacePath: string, workspaceName: string): Promise<void>;

package/dist/commands/wizard/sync-flow.js

@@ -1,67 +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, 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, workspaceName) {
-    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/dist/commands/wizard/update-flow.d.ts

@@ -1,4 +0,0 @@
-/**
- * Update prompts and templates from the package without resetting config
- */
-export declare function runUpdateFlow(workspacePath: string, workspaceName: string, currentStorageMode: string | null): Promise<void>;