rrce-workflow 0.3.13 → 0.3.14

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

@@ -1,85 +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, 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, workspaceName, currentStorageMode) {
-    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 || '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, workspaceName, workspaceRoot, customGlobalPath) {
-    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/dist/commands/wizard/utils.d.ts

@@ -1,9 +0,0 @@
-import type { ParsedPrompt } from '../../types/prompt';
-/**
- * Copy parsed prompts to a target directory with specified extension
- */
-export declare function copyPromptsToDir(prompts: ParsedPrompt[], targetDir: string, extension: string): void;
-/**
- * Recursively copy a directory
- */
-export declare function copyDirRecursive(src: string, dest: string): void;

package/dist/commands/wizard/utils.js

@@ -1,33 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { ensureDir } from '../../lib/paths';
-/**
- * Copy parsed prompts to a target directory with specified extension
- */
-export function copyPromptsToDir(prompts, targetDir, extension) {
-    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, dest) {
-    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/dist/commands/wizard/vscode.d.ts

@@ -1,15 +0,0 @@
-import { type DetectedProject } from '../../lib/detection';
-/**
- * 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 declare function generateVSCodeWorkspace(workspacePath: string, workspaceName: string, linkedProjects: string[] | DetectedProject[], customGlobalPath?: string): void;
-/**
- * Remove a project's folders from the workspace file
- */
-export declare function removeProjectFromWorkspace(workspacePath: string, workspaceName: string, projectName: string): void;

package/dist/commands/wizard/vscode.js

@@ -1,148 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { getRRCEHome } from '../../lib/paths';
-import { getProjectFolders } from '../../lib/detection';
-// 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, workspaceName, linkedProjects, customGlobalPath) {
-    const workspaceFilePath = path.join(workspacePath, `${workspaceName}.code-workspace`);
-    let workspace;
-    // 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 = {
-        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 = [];
-    // 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;
-        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;
-        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 = {};
-        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'] || {};
-        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, workspaceName, projectName) {
-    const workspaceFilePath = path.join(workspacePath, `${workspaceName}.code-workspace`);
-    if (!fs.existsSync(workspaceFilePath)) {
-        return;
-    }
-    try {
-        const content = fs.readFileSync(workspaceFilePath, 'utf-8');
-        const workspace = 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'];
-            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/dist/index.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/lib/autocomplete-prompt.d.ts

@@ -1,14 +0,0 @@
-import { isCancel } from '@clack/core';
-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 declare function directoryAutocomplete(opts: DirectoryAutocompleteOptions): Promise<string | symbol>;
-export { isCancel };

package/dist/lib/autocomplete-prompt.js

@@ -1,167 +0,0 @@
-import { TextPrompt, isCancel } from '@clack/core';
-import * as fs from 'fs';
-import * as path from 'path';
-import pc from 'picocolors';
-/**
- * Custom text input with Tab-completion for directory paths
- * Uses @clack/core TextPrompt with custom key handling
- */
-export async function directoryAutocomplete(opts) {
-    let completions = [];
-    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;
-            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) {
-        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, value) {
-        // 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.value = displayValue;
-    }
-    function formatForDisplay(value) {
-        const home = process.env.HOME || '';
-        return value.startsWith(home)
-            ? value.replace(home, '~')
-            : value;
-    }
-    function getDirectoryCompletions(inputPath) {
-        try {
-            let dirToScan;
-            let prefix;
-            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) {
-        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/dist/lib/detection.d.ts

@@ -1,44 +0,0 @@
-import type { StorageMode } from '../types/prompt';
-/**
- * Detected rrce-workflow project information
- */
-export interface DetectedProject {
-    name: string;
-    path: string;
-    dataPath: string;
-    source: 'global' | 'sibling' | 'parent';
-    storageMode?: StorageMode;
-    knowledgePath?: string;
-    refsPath?: string;
-    tasksPath?: string;
-}
-interface ScanOptions {
-    excludeWorkspace?: string;
-    workspacePath?: string;
-    scanSiblings?: boolean;
-}
-/**
- * Scan for rrce-workflow projects in various locations
- */
-export declare function scanForProjects(options?: ScanOptions): DetectedProject[];
-/**
- * Parse a workspace config file
- */
-export declare function parseWorkspaceConfig(configPath: string): {
-    name: string;
-    storageMode: StorageMode;
-    linkedProjects?: string[];
-} | null;
-/**
- * Get display label for a detected project
- */
-export declare function getProjectDisplayLabel(project: DetectedProject): string;
-/**
- * Get all linkable folders from a detected project
- */
-export declare function getProjectFolders(project: DetectedProject): Array<{
-    path: string;
-    type: 'knowledge' | 'refs' | 'tasks';
-    displayName: string;
-}>;
-export {};