rrce-workflow 0.2.14 → 0.2.16

package/bin/rrce-workflow.js

@@ -1,35 +1,5 @@
 #!/usr/bin/env node
 
-import { spawn } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-
-// Get the directory of this script
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-// Path to tsx in node_modules
-const tsxPath = join(__dirname, '..', 'node_modules', '.bin', 'tsx');
-
-// Path to the main TypeScript file
-const mainPath = join(__dirname, '..', 'src', 'index.ts');
-
-// Get command line arguments (skip node and script path)
-const args = process.argv.slice(2);
-
-// Spawn tsx with the main file and pass through all arguments
-const child = spawn(tsxPath, [mainPath, ...args], {
-  stdio: 'inherit',
-  cwd: process.cwd(),
-});
-
-// Exit with the same code as the child process
-child.on('exit', (code) => {
-  process.exit(code ?? 0);
-});
-
-// Forward signals
-child.on('error', (err) => {
-  console.error('Failed to start:', err.message);
-  process.exit(1);
-});
+// This is the compiled entry point for the CLI
+// The source is in src/index.ts, compiled to dist/index.js
+import('../dist/index.js');

package/dist/commands/selector.d.ts

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

package/dist/commands/selector.js

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

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

package/dist/commands/wizard/index.js

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

@@ -0,0 +1,5 @@
+/**
+ * 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

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

@@ -0,0 +1,4 @@
+/**
+ * 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

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

@@ -0,0 +1,4 @@
+/**
+ * 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

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

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