@nexus-cortex/tui 4.47.0

package/dist/commands/system-message/InteractiveMenu.js

@@ -0,0 +1,979 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * Interactive System Message Menu
+ *
+ * Ink-based terminal UI for managing system messages
+ * Provides list view, navigation, CRUD operations, and AI-powered creation/editing
+ */
+import { useState, useEffect } from 'react';
+import { Box, Text, useInput, useApp } from 'ink';
+import TextInput from 'ink-text-input';
+import Spinner from 'ink-spinner';
+import { InlineEditor } from './InlineEditor.js';
+import * as path from 'path';
+/**
+ * Priority presets for easy selection
+ * Lower priority number = injected first (matches injection system)
+ * Priority 0 = excluded from injection entirely
+ */
+const PRIORITY_PRESETS = [
+    { value: 0, label: 'Disabled (0)', description: 'Excluded from injection - message will not be loaded' },
+    { value: 1, label: 'Critical (1)', description: 'Safety rules - injected first (before everything)' },
+    { value: 5, label: 'High (5)', description: 'Core behavioral instructions - after system prompt' },
+    { value: 8, label: 'Medium (8)', description: 'General guidance - after core messages' },
+    { value: 15, label: 'Low (15)', description: 'Preferences - after periodic reminders (10)' },
+    { value: 50, label: 'Optional (50)', description: 'Optional enhancements - injected last' },
+];
+/**
+ * Interactive System Message Menu Component
+ */
+export const InteractiveMenu = ({ store, runtimeDir, builtinDir, initialMessageId, generateProfile, conversationalCreator, editAssistant, onExit, }) => {
+    const { exit: inkExit } = useApp();
+    // Use onExit callback if provided (for graceful return to CLI), otherwise fall back to Ink's exit
+    const handleExit = () => {
+        if (onExit) {
+            onExit();
+        }
+        else {
+            inkExit();
+        }
+    };
+    const [messages, setMessages] = useState([]);
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [menuState, setMenuState] = useState('list');
+    const [confirmAction, setConfirmAction] = useState(null);
+    const [statusMessage, setStatusMessage] = useState('');
+    const [errorMessage, setErrorMessage] = useState('');
+    // Editing state
+    const [editingMessage, setEditingMessage] = useState(null);
+    const [editingContent, setEditingContent] = useState('');
+    const [editingFilePath, setEditingFilePath] = useState('');
+    // AI edit state
+    const [aiEditRequest, setAiEditRequest] = useState('');
+    const [aiEditResult, setAiEditResult] = useState(null);
+    // Creation state
+    const [createDescription, setCreateDescription] = useState('');
+    const [generatingMessage, setGeneratingMessage] = useState('');
+    // Conversation state for multi-turn creation
+    const [conversationMessages, setConversationMessages] = useState([]);
+    const [conversationInput, setConversationInput] = useState('');
+    const [conversationThinking, setConversationThinking] = useState(false);
+    // Edit choice state
+    const [editChoiceIndex, setEditChoiceIndex] = useState(0);
+    // Priority selection state
+    const [prioritySelectIndex, setPrioritySelectIndex] = useState(3); // Default to Medium (8)
+    const [selectedPriority, setSelectedPriority] = useState(8);
+    const [customPriorityInput, setCustomPriorityInput] = useState('');
+    const [showCustomPriority, setShowCustomPriority] = useState(false);
+    // Load messages on mount
+    useEffect(() => {
+        loadMessages();
+        // Subscribe to store changes for hot-reload
+        const listener = () => {
+            loadMessages();
+        };
+        store.onChange(listener);
+        return () => {
+            store.removeListener(listener);
+        };
+    }, []);
+    // Set initial selection
+    useEffect(() => {
+        if (initialMessageId && messages.length > 0) {
+            const index = messages.findIndex((m) => m.id === initialMessageId);
+            if (index !== -1) {
+                setSelectedIndex(index);
+            }
+        }
+    }, [messages, initialMessageId]);
+    /**
+     * Load messages from store
+     */
+    const loadMessages = () => {
+        const allMessages = store.getAll();
+        // Sort by priority (lower = injected first, show first in list)
+        allMessages.sort((a, b) => {
+            if (a.priority !== b.priority) {
+                return a.priority - b.priority; // Lower priority number first
+            }
+            return a.id.localeCompare(b.id);
+        });
+        setMessages(allMessages);
+    };
+    /**
+     * Get currently selected message
+     */
+    const selectedMessage = messages[selectedIndex];
+    /**
+     * Handle keyboard input for list state
+     */
+    useInput((input, key) => {
+        // Loading/generating state - block all input
+        if (menuState === 'loading' || menuState === 'create-generating' || menuState === 'ai-edit-processing') {
+            return;
+        }
+        // Confirmation prompt state
+        if (menuState === 'confirm' && confirmAction) {
+            if (input.toLowerCase() === 'y') {
+                executeConfirmedAction(confirmAction);
+                setMenuState('list');
+                setConfirmAction(null);
+            }
+            else if (input.toLowerCase() === 'n' || key.escape) {
+                setMenuState('list');
+                setConfirmAction(null);
+                setStatusMessage('Action cancelled');
+            }
+            return;
+        }
+        // List navigation state
+        if (menuState === 'list') {
+            // Navigation
+            if (key.upArrow) {
+                setSelectedIndex((prev) => Math.max(0, prev - 1));
+                setStatusMessage('');
+                setErrorMessage('');
+            }
+            else if (key.downArrow) {
+                setSelectedIndex((prev) => Math.min(messages.length - 1, prev + 1));
+                setStatusMessage('');
+                setErrorMessage('');
+            }
+            // Actions
+            else if (key.return && selectedMessage) {
+                // Edit message - start with priority confirmation
+                // Find the matching priority preset or use custom
+                const currentPriority = selectedMessage.priority;
+                const presetIndex = PRIORITY_PRESETS.findIndex(p => p.value === currentPriority);
+                if (presetIndex !== -1) {
+                    setPrioritySelectIndex(presetIndex);
+                }
+                else {
+                    setPrioritySelectIndex(PRIORITY_PRESETS.length); // Custom option
+                }
+                setSelectedPriority(currentPriority);
+                setShowCustomPriority(false);
+                setCustomPriorityInput('');
+                setMenuState('edit-priority');
+            }
+            else if (input === ' ' && selectedMessage) {
+                // Toggle enabled state
+                handleToggle(selectedMessage.id);
+            }
+            else if (input === '+') {
+                // Create new message - start with priority selection
+                setCreateDescription('');
+                setConversationMessages([]);
+                setConversationInput('');
+                setPrioritySelectIndex(3); // Default to Medium (8)
+                setSelectedPriority(8);
+                setShowCustomPriority(false);
+                setCustomPriorityInput('');
+                setMenuState('create-priority');
+            }
+            else if (input.toLowerCase() === 'r' && selectedMessage) {
+                // Reset to default
+                if (selectedMessage.source === 'runtime' || selectedMessage.source === 'workspace') {
+                    setConfirmAction({ type: 'reset', messageId: selectedMessage.id });
+                    setMenuState('confirm');
+                }
+                else {
+                    setErrorMessage('Cannot reset builtin message');
+                }
+            }
+            else if (input.toLowerCase() === 'd' && selectedMessage) {
+                // Delete message
+                if (selectedMessage.source === 'runtime') {
+                    setConfirmAction({ type: 'delete', messageId: selectedMessage.id });
+                    setMenuState('confirm');
+                }
+                else {
+                    setErrorMessage('Can only delete runtime messages');
+                }
+            }
+            else if (input.toLowerCase() === 'q' || key.escape) {
+                // Quit - use handleExit for graceful return to CLI
+                handleExit();
+            }
+        }
+    }, { isActive: menuState === 'list' || menuState === 'confirm' });
+    /**
+     * Handle keyboard input for edit choice state
+     */
+    useInput((_input, key) => {
+        if (key.upArrow || key.downArrow) {
+            setEditChoiceIndex((prev) => (prev === 0 ? 1 : 0));
+        }
+        else if (key.return) {
+            if (editChoiceIndex === 0 && selectedMessage) {
+                // Direct edit - update priority first if changed, then edit
+                handleDirectEditWithPriority(selectedMessage.id, selectedPriority).catch((err) => {
+                    setErrorMessage(`Edit failed: ${err.message}`);
+                    setMenuState('list');
+                });
+            }
+            else if (editChoiceIndex === 1 && selectedMessage) {
+                // AI-assisted edit - update priority first if changed, then edit
+                handleAiEditStartWithPriority(selectedMessage.id, selectedPriority).catch((err) => {
+                    setErrorMessage(`Edit failed: ${err.message}`);
+                    setMenuState('list');
+                });
+            }
+        }
+        else if (key.escape) {
+            setMenuState('list');
+        }
+    }, { isActive: menuState === 'edit-choice' });
+    /**
+     * Handle keyboard input for AI edit request state (escape to cancel)
+     */
+    useInput((_input, key) => {
+        if (key.escape) {
+            setAiEditRequest('');
+            setMenuState('list');
+        }
+    }, { isActive: menuState === 'ai-edit-request' });
+    /**
+     * Handle keyboard input for conversation state (escape to cancel)
+     */
+    useInput((_input, key) => {
+        if (key.escape && !conversationThinking) {
+            handleConversationCancel();
+        }
+    }, { isActive: menuState === 'create-conversation' || menuState === 'create-description' });
+    /**
+     * Handle keyboard input for priority selection (create and edit)
+     */
+    useInput((input, key) => {
+        if (showCustomPriority) {
+            // In custom priority input mode - only handle escape
+            if (key.escape) {
+                setShowCustomPriority(false);
+                setCustomPriorityInput('');
+            }
+            return;
+        }
+        if (key.upArrow) {
+            setPrioritySelectIndex((prev) => Math.max(0, prev - 1));
+        }
+        else if (key.downArrow) {
+            setPrioritySelectIndex((prev) => Math.min(PRIORITY_PRESETS.length, prev + 1)); // +1 for custom option
+        }
+        else if (key.return) {
+            if (prioritySelectIndex < PRIORITY_PRESETS.length) {
+                // Selected a preset
+                const preset = PRIORITY_PRESETS[prioritySelectIndex];
+                if (preset) {
+                    setSelectedPriority(preset.value);
+                    if (menuState === 'create-priority') {
+                        // Continue to description step
+                        setMenuState('create-description');
+                    }
+                    else if (menuState === 'edit-priority') {
+                        // Continue to edit choice
+                        setMenuState('edit-choice');
+                    }
+                }
+            }
+            else {
+                // Selected "Custom" option
+                setShowCustomPriority(true);
+                setCustomPriorityInput('');
+            }
+        }
+        else if (key.escape) {
+            setMenuState('list');
+        }
+        else if (input === 'c' || input === 'C') {
+            // Shortcut for custom priority
+            setShowCustomPriority(true);
+            setCustomPriorityInput('');
+        }
+    }, { isActive: (menuState === 'create-priority' || menuState === 'edit-priority') && !showCustomPriority });
+    /**
+     * Handle custom priority input submission
+     */
+    const handleCustomPrioritySubmit = () => {
+        const value = parseInt(customPriorityInput, 10);
+        if (!isNaN(value) && value >= 1 && value <= 100) {
+            setSelectedPriority(value);
+            setShowCustomPriority(false);
+            setCustomPriorityInput('');
+            if (menuState === 'create-priority') {
+                setMenuState('create-description');
+            }
+            else if (menuState === 'edit-priority') {
+                setMenuState('edit-choice');
+            }
+        }
+        else {
+            setErrorMessage('Priority must be a number between 1 and 100');
+        }
+    };
+    /**
+     * Execute confirmed action
+     */
+    const executeConfirmedAction = async (action) => {
+        setMenuState('loading');
+        setStatusMessage('');
+        setErrorMessage('');
+        try {
+            switch (action.type) {
+                case 'reset':
+                    await handleReset(action.messageId);
+                    break;
+                case 'delete':
+                    await handleDelete(action.messageId);
+                    break;
+                case 'create':
+                    await handleLegacyCreate();
+                    break;
+                case 'save-ai-edit':
+                    await saveAiEdit(action.messageId, action.newContent);
+                    break;
+            }
+        }
+        catch (error) {
+            setErrorMessage(error.message);
+        }
+        finally {
+            setMenuState('list');
+        }
+    };
+    /**
+     * Handle direct edit action - opens inline editor
+     */
+    const handleDirectEdit = async (messageId) => {
+        const message = store.getMessage(messageId);
+        if (!message) {
+            setErrorMessage(`Message '${messageId}' not found`);
+            return;
+        }
+        try {
+            // Determine file path
+            let filePath;
+            // Special case: CORTEX.md is in .cortex/, not .cortex/system-messages/
+            // Uses same lookup logic as SystemMessageStore/SystemMessageLoader:
+            // 1. Project-level: {projectRoot}/.cortex/CORTEX.md
+            // 2. Global fallback: ~/.cortex/CORTEX.md
+            if (messageId === 'cortex') {
+                const fs = await import('fs/promises');
+                // Try project-level first
+                const projectRoot = path.dirname(path.dirname(runtimeDir));
+                const projectCortexPath = path.join(projectRoot, '.cortex', 'CORTEX.md');
+                try {
+                    await fs.access(projectCortexPath);
+                    filePath = projectCortexPath;
+                }
+                catch {
+                    // Try global fallback
+                    const homeDir = process.env.HOME || process.env.USERPROFILE || '~';
+                    const globalCortexPath = path.join(homeDir, '.cortex', 'CORTEX.md');
+                    try {
+                        await fs.access(globalCortexPath);
+                        filePath = globalCortexPath;
+                    }
+                    catch {
+                        // Neither exists - use project path (will fail later with helpful error)
+                        filePath = projectCortexPath;
+                    }
+                }
+            }
+            else if (message.source === 'runtime') {
+                filePath = path.join(runtimeDir, message.path);
+            }
+            else if (message.source === 'builtin') {
+                // Create runtime override
+                const fileName = messageId.toUpperCase() + '.md';
+                filePath = path.join(runtimeDir, 'messages', fileName);
+                // Copy builtin to runtime if doesn't exist
+                const builtinPath = path.join(builtinDir, message.path);
+                const fs = await import('fs/promises');
+                try {
+                    await fs.access(filePath);
+                }
+                catch {
+                    // File doesn't exist, copy from builtin
+                    const content = await fs.readFile(builtinPath, 'utf-8');
+                    await fs.mkdir(path.dirname(filePath), { recursive: true });
+                    await fs.writeFile(filePath, content, 'utf-8');
+                    // Add to registry
+                    const { SystemMessageRegistry } = await import('@nexus-cortex/core/system-messages/SystemMessageRegistry.js');
+                    const registry = new SystemMessageRegistry(runtimeDir);
+                    await registry.load();
+                    const entry = SystemMessageRegistry.createEntry(messageId, message.type, `messages/${fileName}`, {
+                        priority: message.priority,
+                        description: message.metadata.description,
+                        displayName: message.metadata.displayName,
+                    });
+                    await registry.add(entry);
+                }
+            }
+            else {
+                filePath = path.join(builtinDir, message.path);
+            }
+            // Load file content
+            const fs = await import('fs/promises');
+            const content = await fs.readFile(filePath, 'utf-8');
+            // Set editing state and open inline editor
+            setEditingMessage(message);
+            setEditingContent(content);
+            setEditingFilePath(filePath);
+            setMenuState('editing');
+        }
+        catch (error) {
+            setErrorMessage(`Failed to open editor: ${error.message}`);
+            setMenuState('list');
+        }
+    };
+    /**
+     * Start AI-assisted edit
+     */
+    const handleAiEditStart = async (messageId) => {
+        const message = store.getMessage(messageId);
+        if (!message) {
+            setErrorMessage(`Message '${messageId}' not found`);
+            return;
+        }
+        try {
+            // Load current content
+            let filePath;
+            // Special case: CORTEX.md is in .cortex/, not .cortex/system-messages/
+            if (messageId === 'cortex') {
+                const projectRoot = path.dirname(path.dirname(runtimeDir));
+                filePath = path.join(projectRoot, message.path);
+            }
+            else if (message.source === 'runtime') {
+                filePath = path.join(runtimeDir, message.path);
+            }
+            else if (message.source === 'builtin') {
+                filePath = path.join(builtinDir, message.path);
+            }
+            else {
+                filePath = path.join(builtinDir, message.path);
+            }
+            const fs = await import('fs/promises');
+            const content = await fs.readFile(filePath, 'utf-8');
+            setEditingMessage(message);
+            setEditingContent(content);
+            setEditingFilePath(filePath);
+            setAiEditRequest('');
+            setAiEditResult(null);
+            setMenuState('ai-edit-request');
+        }
+        catch (error) {
+            setErrorMessage(`Failed to load message content: ${error.message}`);
+            setMenuState('list');
+        }
+    };
+    /**
+     * Update priority in registry if changed
+     */
+    const updatePriorityIfChanged = async (messageId, newPriority) => {
+        const message = store.getMessage(messageId);
+        if (!message || message.priority === newPriority) {
+            return; // No change needed
+        }
+        try {
+            // Use the store's method to update priority (handles registry + in-memory update)
+            await store.updateMessagePriority(messageId, newPriority);
+            // Refresh local messages state
+            loadMessages();
+            setStatusMessage(`Priority updated to ${newPriority}`);
+        }
+        catch (error) {
+            console.error('Failed to update priority:', error);
+            setErrorMessage(`Failed to update priority: ${error.message}`);
+        }
+    };
+    /**
+     * Handle direct edit with priority update
+     */
+    const handleDirectEditWithPriority = async (messageId, priority) => {
+        await updatePriorityIfChanged(messageId, priority);
+        await handleDirectEdit(messageId);
+    };
+    /**
+     * Handle AI-assisted edit with priority update
+     */
+    const handleAiEditStartWithPriority = async (messageId, priority) => {
+        await updatePriorityIfChanged(messageId, priority);
+        await handleAiEditStart(messageId);
+    };
+    /**
+     * Handle AI edit request submission
+     */
+    const handleAiEditSubmit = async () => {
+        if (!aiEditRequest.trim() || !editAssistant || !editingMessage) {
+            return;
+        }
+        setMenuState('ai-edit-processing');
+        setErrorMessage('');
+        try {
+            const result = await editAssistant(editingContent, aiEditRequest);
+            setAiEditResult(result);
+            // Show confirmation to save
+            setConfirmAction({
+                type: 'save-ai-edit',
+                messageId: editingMessage.id,
+                newContent: result.content,
+            });
+            setMenuState('confirm');
+        }
+        catch (error) {
+            setErrorMessage(`AI edit failed: ${error.message}`);
+            setMenuState('list');
+        }
+    };
+    /**
+     * Save AI-edited content
+     */
+    const saveAiEdit = async (messageId, newContent) => {
+        const message = store.getMessage(messageId);
+        if (!message) {
+            throw new Error(`Message '${messageId}' not found`);
+        }
+        // Determine file path
+        let filePath;
+        if (message.source === 'runtime') {
+            filePath = path.join(runtimeDir, message.path);
+        }
+        else if (message.source === 'builtin') {
+            // Create runtime override
+            const fileName = messageId.toUpperCase() + '.md';
+            filePath = path.join(runtimeDir, 'messages', fileName);
+            // Ensure directory exists
+            const fs = await import('fs/promises');
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
+            // Add to registry if new
+            const { SystemMessageRegistry } = await import('@nexus-cortex/core/system-messages/SystemMessageRegistry.js');
+            const registry = new SystemMessageRegistry(runtimeDir);
+            await registry.load();
+            try {
+                await fs.access(filePath);
+            }
+            catch {
+                // File doesn't exist, add to registry
+                const entry = SystemMessageRegistry.createEntry(messageId, message.type, `messages/${fileName}`, {
+                    priority: message.priority,
+                    description: message.metadata.description,
+                    displayName: message.metadata.displayName,
+                });
+                await registry.add(entry);
+            }
+        }
+        else {
+            throw new Error('Cannot edit workspace messages');
+        }
+        // Write file
+        const fs = await import('fs/promises');
+        await fs.writeFile(filePath, newContent, 'utf-8');
+        // Immediately reload the message in the store to pick up content changes (like displayName)
+        await store.reloadMessageFile(filePath, 'runtime');
+        const summary = aiEditResult?.summary || 'Content updated';
+        setStatusMessage(`Message '${messageId}' updated: ${summary}`);
+        // Clear editing state
+        setEditingMessage(null);
+        setEditingContent('');
+        setEditingFilePath('');
+        setAiEditRequest('');
+        setAiEditResult(null);
+        // Refresh list to show updated data
+        loadMessages();
+    };
+    /**
+     * Handle save from inline editor
+     */
+    const handleEditorSave = async (newContent) => {
+        if (!editingFilePath || !editingMessage) {
+            return;
+        }
+        try {
+            // Write file
+            const fs = await import('fs/promises');
+            await fs.writeFile(editingFilePath, newContent, 'utf-8');
+            // Immediately reload the message in the store to pick up content changes (like displayName)
+            await store.reloadMessageFile(editingFilePath, 'runtime');
+            setStatusMessage(`Message '${editingMessage.id}' saved successfully`);
+            setMenuState('list');
+            // Clear editing state
+            setEditingMessage(null);
+            setEditingContent('');
+            setEditingFilePath('');
+            // Refresh list to show updated data
+            loadMessages();
+        }
+        catch (error) {
+            setErrorMessage(`Failed to save: ${error.message}`);
+            setMenuState('list');
+        }
+    };
+    /**
+     * Handle cancel from inline editor
+     */
+    const handleEditorCancel = () => {
+        setMenuState('list');
+        // Clear editing state
+        setEditingMessage(null);
+        setEditingContent('');
+        setEditingFilePath('');
+    };
+    /**
+     * Handle toggle action
+     */
+    const handleToggle = async (messageId) => {
+        try {
+            const newState = await store.toggleEnabled(messageId);
+            setStatusMessage(`Message '${messageId}' ${newState ? 'enabled' : 'disabled'}`);
+            loadMessages(); // Refresh list
+        }
+        catch (error) {
+            setErrorMessage(error.message);
+        }
+    };
+    /**
+     * Handle reset action
+     */
+    const handleReset = async (messageId) => {
+        try {
+            await store.resetToDefault(messageId);
+            setStatusMessage(`Message '${messageId}' reset to default`);
+            loadMessages();
+        }
+        catch (error) {
+            setErrorMessage(error.message);
+        }
+    };
+    /**
+     * Handle delete action
+     */
+    const handleDelete = async (messageId) => {
+        try {
+            await store.deleteMessage(messageId);
+            setStatusMessage(`Message '${messageId}' deleted`);
+            loadMessages();
+            // Adjust selection if needed
+            if (selectedIndex >= messages.length - 1) {
+                setSelectedIndex(Math.max(0, messages.length - 2));
+            }
+        }
+        catch (error) {
+            setErrorMessage(error.message);
+        }
+    };
+    /**
+     * Handle legacy create action (no AI)
+     */
+    const handleLegacyCreate = async () => {
+        const id = `custom_${Date.now()}`;
+        try {
+            await store.createMessage({
+                id,
+                type: 'instruction',
+                displayName: `Custom Message ${Date.now()}`,
+                description: 'Custom system message',
+                priority: 50,
+            });
+            setStatusMessage(`Created new message '${id}' - edit to customize`);
+            loadMessages();
+            // Select the new message
+            const newIndex = messages.findIndex((m) => m.id === id);
+            if (newIndex !== -1) {
+                setSelectedIndex(newIndex);
+            }
+        }
+        catch (error) {
+            setErrorMessage(error.message);
+        }
+    };
+    /**
+     * Handle description submission - starts conversation
+     */
+    const handleDescriptionSubmit = async () => {
+        if (!createDescription.trim()) {
+            setErrorMessage('Please enter a description for your system message');
+            return;
+        }
+        setErrorMessage('');
+        // Start the conversation flow
+        if (conversationalCreator) {
+            const initialMessage = {
+                role: 'user',
+                content: createDescription,
+            };
+            setConversationMessages([initialMessage]);
+            setConversationThinking(true);
+            setMenuState('create-conversation');
+            // Get first AI response (likely a clarifying question)
+            try {
+                const response = await conversationalCreator([initialMessage]);
+                setConversationThinking(false);
+                if (response.type === 'profile' && response.profile) {
+                    // AI generated profile directly without questions
+                    await createMessageFromProfile(response.profile);
+                }
+                else if (response.type === 'question' && response.question) {
+                    // AI is asking a clarifying question
+                    const questionText = response.question;
+                    setConversationMessages((prev) => [
+                        ...prev,
+                        { role: 'assistant', content: questionText },
+                    ]);
+                }
+            }
+            catch (error) {
+                setConversationThinking(false);
+                setErrorMessage(`AI error: ${error.message}`);
+                setMenuState('list');
+            }
+            return;
+        }
+        // Fallback to legacy one-shot generation
+        setMenuState('create-generating');
+        setGeneratingMessage('Generating system message...');
+        try {
+            let profile;
+            if (generateProfile) {
+                // Use AI to generate the profile
+                profile = await generateProfile(createDescription);
+            }
+            else {
+                // Fallback: Create a basic profile
+                const safeId = createDescription
+                    .toLowerCase()
+                    .replace(/[^a-z0-9]+/g, '-')
+                    .replace(/^-|-$/g, '')
+                    .slice(0, 48) || `message-${Date.now()}`;
+                profile = {
+                    id: safeId,
+                    type: 'instruction',
+                    displayName: createDescription.slice(0, 50),
+                    description: createDescription.slice(0, 200),
+                    priority: 50,
+                    content: `# ${createDescription.slice(0, 50)}\n\n${createDescription}\n\n## Guidelines\n\n- Follow the instructions above\n- Be thorough and consistent`,
+                };
+            }
+            await createMessageFromProfile(profile);
+        }
+        catch (error) {
+            setErrorMessage(`Failed to create message: ${error.message}`);
+            setMenuState('list');
+        }
+    };
+    /**
+     * Handle user response in conversation flow
+     */
+    const handleConversationSubmit = async () => {
+        if (!conversationInput.trim() || !conversationalCreator) {
+            return;
+        }
+        // Add user message to conversation
+        const userMessage = {
+            role: 'user',
+            content: conversationInput,
+        };
+        const updatedMessages = [...conversationMessages, userMessage];
+        setConversationMessages(updatedMessages);
+        setConversationInput('');
+        setConversationThinking(true);
+        setErrorMessage('');
+        try {
+            const response = await conversationalCreator(updatedMessages);
+            setConversationThinking(false);
+            if (response.type === 'profile' && response.profile) {
+                // AI generated the final profile
+                await createMessageFromProfile(response.profile);
+            }
+            else if (response.type === 'question' && response.question) {
+                // AI is asking another clarifying question
+                const questionText = response.question;
+                setConversationMessages((prev) => [
+                    ...prev,
+                    { role: 'assistant', content: questionText },
+                ]);
+            }
+        }
+        catch (error) {
+            setConversationThinking(false);
+            setErrorMessage(`AI error: ${error.message}`);
+        }
+    };
+    /**
+     * Create message from generated profile
+     */
+    const createMessageFromProfile = async (profile) => {
+        setMenuState('create-generating');
+        setGeneratingMessage('Saving system message...');
+        try {
+            // Create the message file
+            const fileName = profile.id.toUpperCase() + '.md';
+            const filePath = path.join(runtimeDir, 'messages', fileName);
+            const fs = await import('fs/promises');
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
+            await fs.writeFile(filePath, profile.content, 'utf-8');
+            // Add to registry
+            const { SystemMessageRegistry } = await import('@nexus-cortex/core/system-messages/SystemMessageRegistry.js');
+            const registry = new SystemMessageRegistry(runtimeDir);
+            await registry.load();
+            const entry = SystemMessageRegistry.createEntry(profile.id, profile.type, `messages/${fileName}`, {
+                priority: selectedPriority, // Use user-selected priority
+                description: profile.description,
+                displayName: profile.displayName,
+            });
+            await registry.add(entry);
+            // Immediately reload the new message in the store
+            await store.reloadMessageFile(filePath, 'runtime');
+            setStatusMessage(`Created system message '${profile.id}' successfully!`);
+            // Reset all creation state
+            resetCreationState();
+            setMenuState('list');
+            // Refresh list and select the new message
+            loadMessages();
+            setTimeout(() => {
+                const newIndex = store.getAll().findIndex((m) => m.id === profile.id);
+                if (newIndex !== -1) {
+                    setSelectedIndex(newIndex);
+                }
+            }, 50);
+        }
+        catch (error) {
+            setErrorMessage(`Failed to create message: ${error.message}`);
+            setMenuState('list');
+        }
+    };
+    /**
+     * Reset all creation-related state
+     */
+    const resetCreationState = () => {
+        setCreateDescription('');
+        setConversationMessages([]);
+        setConversationInput('');
+        setConversationThinking(false);
+        setGeneratingMessage('');
+    };
+    /**
+     * Cancel conversation and return to list
+     */
+    const handleConversationCancel = () => {
+        resetCreationState();
+        setMenuState('list');
+    };
+    /**
+     * Render priority selection
+     */
+    const renderPrioritySelection = () => {
+        const isEditing = menuState === 'edit-priority';
+        const title = isEditing
+            ? `Set Priority for '${selectedMessage?.metadata?.displayName || selectedMessage?.id}'`
+            : 'Step 1: Select Priority';
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "cyan", children: title }) }), isEditing && selectedMessage && (_jsx(Box, { marginBottom: 1, flexDirection: "column", children: _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "Current priority: " }), _jsx(Text, { color: selectedMessage.priority === 0 ? 'red' : 'yellow', children: selectedMessage.priority }), selectedMessage.priority === 0 && (_jsx(Text, { color: "red", bold: true, children: " (EXCLUDED FROM INJECTION)" }))] }) })), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Select priority level (lower number = injected first):" }) }), showCustomPriority ? (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { borderStyle: "single", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { color: "cyan", children: "Custom priority (1-100): " }), _jsx(TextInput, { value: customPriorityInput, onChange: setCustomPriorityInput, onSubmit: handleCustomPrioritySubmit, placeholder: "e.g., 75" })] }), errorMessage && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "red", children: errorMessage }) }))] })) : (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [PRIORITY_PRESETS.map((preset, index) => {
+                            const isSelected = index === prioritySelectIndex;
+                            return (_jsxs(Box, { paddingLeft: isSelected ? 0 : 2, children: [isSelected && _jsx(Text, { color: "cyan", bold: true, children: '> ' }), _jsx(Text, { bold: isSelected, color: isSelected ? 'cyan' : undefined, children: preset.label }), _jsxs(Text, { dimColor: true, children: [" - ", preset.description] })] }, preset.value));
+                        }), _jsxs(Box, { paddingLeft: prioritySelectIndex === PRIORITY_PRESETS.length ? 0 : 2, children: [prioritySelectIndex === PRIORITY_PRESETS.length && _jsx(Text, { color: "cyan", bold: true, children: '> ' }), _jsx(Text, { bold: prioritySelectIndex === PRIORITY_PRESETS.length, color: prioritySelectIndex === PRIORITY_PRESETS.length ? 'cyan' : undefined, children: "Custom..." }), _jsx(Text, { dimColor: true, children: " - Enter a specific priority value" })] })] })), _jsx(Box, { borderStyle: "single", borderColor: "gray", paddingX: 1, children: _jsx(Text, { dimColor: true, children: showCustomPriority
+                            ? 'Enter: Confirm | Esc: Back to presets'
+                            : `${String.fromCharCode(8593)}/${String.fromCharCode(8595)}: Navigate | Enter: Select | C: Custom | Esc: Cancel` }) })] }));
+    };
+    const renderEditChoice = () => {
+        if (!selectedMessage)
+            return null;
+        const choices = [
+            { label: 'Edit directly', description: 'Open in inline editor for manual editing' },
+            { label: 'AI-assisted edit', description: 'Describe changes and let AI update the content' },
+        ];
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, color: "cyan", children: ["Edit '", selectedMessage.id, "'"] }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "How would you like to edit this system message?" }) }), _jsx(Box, { flexDirection: "column", marginBottom: 1, children: choices.map((choice, index) => {
+                        const isSelected = index === editChoiceIndex;
+                        return (_jsxs(Box, { paddingLeft: isSelected ? 0 : 2, children: [isSelected && _jsx(Text, { color: "cyan", bold: true, children: '> ' }), _jsx(Text, { bold: isSelected, color: isSelected ? 'cyan' : undefined, children: choice.label }), _jsxs(Text, { dimColor: true, children: [" - ", choice.description] })] }, choice.label));
+                    }) }), _jsx(Box, { borderStyle: "single", borderColor: "gray", paddingX: 1, children: _jsxs(Text, { dimColor: true, children: [String.fromCharCode(8593), "/", String.fromCharCode(8595), ": Navigate | Enter: Select | Esc: Cancel"] }) })] }));
+    };
+    /**
+     * Render AI edit request input
+     */
+    const renderAiEditRequest = () => {
+        if (!editingMessage)
+            return null;
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, color: "cyan", children: ["AI-Assisted Edit: '", editingMessage.id, "'"] }) }), _jsxs(Box, { marginBottom: 1, flexDirection: "column", children: [_jsx(Text, { children: "Describe what changes you want to make:" }), _jsx(Text, { dimColor: true, children: "(e.g., \"Add a section about error handling\", \"Make the tone more formal\")" })] }), _jsx(Box, { borderStyle: "single", borderColor: "cyan", paddingX: 1, paddingY: 0, children: _jsx(TextInput, { value: aiEditRequest, onChange: setAiEditRequest, onSubmit: handleAiEditSubmit, placeholder: "E.g., Add examples for edge cases, simplify the language, restructure into clearer sections..." }) }), errorMessage && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "red", children: ['!', " ", errorMessage] }) })), _jsx(Box, { borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Enter: Generate Changes | Esc: Cancel" }) })] }));
+    };
+    /**
+     * Render AI edit processing state
+     */
+    const renderAiEditProcessing = () => {
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "cyan", children: "Processing Your Edit Request" }) }), _jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { children: " AI is analyzing and updating the content..." })] }), _jsx(Box, { marginTop: 1, borderStyle: "single", borderColor: "gray", paddingX: 1, children: _jsxs(Text, { dimColor: true, children: ["Request: \"", aiEditRequest, "\""] }) })] }));
+    };
+    /**
+     * Render confirmation prompt
+     */
+    const renderConfirmation = () => {
+        if (!confirmAction)
+            return null;
+        let promptText = '';
+        let warningText = '';
+        switch (confirmAction.type) {
+            case 'reset':
+                promptText = `Reset message '${confirmAction.messageId}' to builtin default?`;
+                warningText = 'Your custom changes will be lost.';
+                break;
+            case 'delete':
+                promptText = `Delete message '${confirmAction.messageId}'?`;
+                warningText = 'This action cannot be undone.';
+                break;
+            case 'create':
+                promptText = 'Create new custom message?';
+                break;
+            case 'save-ai-edit':
+                promptText = `Save AI-generated changes to '${confirmAction.messageId}'?`;
+                if (aiEditResult?.summary) {
+                    warningText = `Changes: ${aiEditResult.summary}`;
+                }
+                break;
+        }
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "yellow", children: "Confirmation Required" }) }), _jsx(Box, { marginBottom: warningText ? 1 : 0, children: _jsx(Text, { children: promptText }) }), warningText && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: warningText }) })), _jsx(Box, { children: _jsxs(Text, { children: ["Press ", _jsx(Text, { bold: true, color: "green", children: "Y" }), " to confirm, ", _jsx(Text, { bold: true, color: "red", children: "N" }), " to cancel"] }) })] }));
+    };
+    /**
+     * Render description input step
+     */
+    const renderDescriptionInput = () => {
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "cyan", children: "Create New System Message" }) }), _jsxs(Box, { marginBottom: 1, flexDirection: "column", children: [_jsx(Text, { children: "Describe the system message you want to create:" }), _jsx(Text, { dimColor: true, children: "(What should it instruct, constrain, or provide context about?)" })] }), _jsx(Box, { borderStyle: "single", borderColor: "cyan", paddingX: 1, paddingY: 0, children: _jsx(TextInput, { value: createDescription, onChange: setCreateDescription, onSubmit: handleDescriptionSubmit, placeholder: "E.g., A code style guide for TypeScript that enforces consistent naming conventions..." }) }), errorMessage && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "red", children: ['!', " ", errorMessage] }) })), _jsx(Box, { borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Enter: Continue | Esc: Cancel" }) })] }));
+    };
+    /**
+     * Render conversation mode - multi-turn creation
+     */
+    const renderConversation = () => {
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "cyan", children: "Creating System Message - Conversation" }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Answer the AI's questions to refine your system message" }) }), _jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, paddingY: 1, marginBottom: 1, children: [conversationMessages.map((msg, index) => (_jsx(Box, { marginBottom: index < conversationMessages.length - 1 ? 1 : 0, children: msg.role === 'user' ? (_jsxs(Box, { children: [_jsx(Text, { color: "blue", bold: true, children: "You: " }), _jsx(Text, { children: msg.content })] })) : (_jsxs(Box, { children: [_jsx(Text, { color: "magenta", bold: true, children: "AI: " }), _jsx(Text, { children: msg.content })] })) }, index))), conversationThinking && (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { dimColor: true, children: " AI is thinking..." })] }))] }), !conversationThinking && (_jsxs(Box, { borderStyle: "single", borderColor: "cyan", paddingX: 1, children: [_jsxs(Text, { color: "cyan", children: ['>', " "] }), _jsx(TextInput, { value: conversationInput, onChange: setConversationInput, onSubmit: handleConversationSubmit, placeholder: "Type your response..." })] })), errorMessage && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "red", children: ['!', " ", errorMessage] }) })), _jsx(Box, { borderStyle: "single", borderColor: "gray", paddingX: 1, marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Enter: Submit response | Esc: Cancel creation" }) })] }));
+    };
+    /**
+     * Render generating state
+     */
+    const renderGenerating = () => {
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "cyan", children: "Creating Your System Message" }) }), _jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsxs(Text, { children: [" ", generatingMessage] })] }), _jsx(Box, { marginTop: 1, borderStyle: "single", borderColor: "gray", paddingX: 1, children: _jsx(Text, { dimColor: true, children: "The AI is generating a detailed system message based on your description..." }) })] }));
+    };
+    /**
+     * Render message list
+     */
+    const renderList = () => {
+        if (messages.length === 0) {
+            return (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "No messages found" }) }));
+        }
+        return (_jsx(Box, { flexDirection: "column", marginTop: 1, children: messages.map((msg, index) => {
+                const isSelected = index === selectedIndex;
+                const enabledIcon = msg.enabled ? String.fromCharCode(10003) : String.fromCharCode(10007);
+                const sourceIcon = msg.source === 'runtime' ? String.fromCharCode(9998) :
+                    msg.source === 'workspace' ? String.fromCharCode(9881) :
+                        String.fromCharCode(128230);
+                // Priority 0 means excluded from injection
+                const isExcluded = msg.priority === 0;
+                return (_jsxs(Box, { paddingLeft: isSelected ? 0 : 2, children: [isSelected && _jsxs(Text, { color: "cyan", bold: true, children: [String.fromCharCode(9654), " "] }), _jsx(Text, { color: msg.enabled ? 'green' : 'red', children: enabledIcon }), _jsx(Text, { children: " " }), _jsx(Text, { children: sourceIcon }), _jsx(Text, { children: " " }), _jsx(Text, { bold: isSelected, color: isSelected ? 'cyan' : isExcluded ? 'gray' : undefined, strikethrough: isExcluded, children: msg.metadata?.displayName || msg.id }), isExcluded ? (_jsx(Text, { color: "yellow", children: " (DISABLED - priority 0)" })) : (_jsxs(Text, { dimColor: true, children: [" (", msg.type, ", priority: ", msg.priority, ")"] }))] }, msg.id));
+            }) }));
+    };
+    /**
+     * Render status bar
+     */
+    const renderStatusBar = () => {
+        const hasAI = conversationalCreator || generateProfile;
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, borderStyle: "single", borderColor: "gray", paddingX: 1, children: [_jsx(Box, { justifyContent: "space-between", children: _jsxs(Text, { dimColor: true, children: [String.fromCharCode(8593), "/", String.fromCharCode(8595), ": Navigate | Enter: Edit | Space: Toggle | +: New", hasAI ? ' (AI)' : '', " | R: Reset | D: Delete | Q: Quit"] }) }), statusMessage && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "green", children: [String.fromCharCode(10003), " ", statusMessage] }) })), errorMessage && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "red", children: [String.fromCharCode(10007), " ", errorMessage] }) })), selectedMessage && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Selected: ", selectedMessage.id, " | Source: ", selectedMessage.source, " |", ' ', "Path: ", selectedMessage.path] }) }))] }));
+    };
+    /**
+     * Main render
+     */
+    return (_jsxs(Box, { flexDirection: "column", padding: menuState === 'editing' ? 0 : 1, children: [menuState === 'editing' && editingContent && editingFilePath && (_jsx(InlineEditor, { content: editingContent, filePath: editingFilePath, onSave: handleEditorSave, onCancel: handleEditorCancel })), menuState !== 'editing' && (_jsxs(_Fragment, { children: [_jsxs(Box, { borderStyle: "bold", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "System Message Manager" }), _jsx(Text, { children: " " }), _jsxs(Text, { dimColor: true, children: ["(", messages.length, " messages)"] }), (conversationalCreator || generateProfile) && (_jsx(Text, { color: "magenta", children: " [AI-Assisted]" }))] }), menuState === 'loading' && (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { children: " Processing..." })] })), (menuState === 'create-priority' || menuState === 'edit-priority') && renderPrioritySelection(), menuState === 'edit-choice' && renderEditChoice(), menuState === 'ai-edit-request' && renderAiEditRequest(), menuState === 'ai-edit-processing' && renderAiEditProcessing(), menuState === 'confirm' && renderConfirmation(), menuState === 'create-description' && renderDescriptionInput(), menuState === 'create-conversation' && renderConversation(), menuState === 'create-generating' && renderGenerating(), menuState === 'list' && renderList(), menuState === 'list' && renderStatusBar()] }))] }));
+};
+//# sourceMappingURL=InteractiveMenu.js.map