dexto 1.3.0 → 1.5.0

package/dist/cli/ink-cli/components/overlays/ModelSelectorRefactored.js

@@ -1,34 +1,116 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 /**
  * ModelSelector Component (Refactored)
- * Now a thin wrapper around BaseSelector
- * Eliminates ~200 lines of code by using base component
+ * Features:
+ * - Search filtering
+ * - Custom models support (add/edit/delete via arrow navigation)
  */
-import { useState, useEffect } from 'react';
-import { Text } from 'ink';
-import { logger } from '@dexto/core';
-import { BaseSelector } from '../base/BaseSelector.js';
+import { useState, useEffect, forwardRef, useRef, useImperativeHandle, useMemo, useCallback, } from 'react';
+import { Box, Text } from 'ink';
+import { listOllamaModels, DEFAULT_OLLAMA_URL, getLocalModelById } from '@dexto/core';
+import { loadCustomModels, deleteCustomModel, getAllInstalledModels, } from '@dexto/agent-management';
+function isAddCustomOption(item) {
+    return 'type' in item && item.type === 'add-custom';
+}
+const MAX_VISIBLE_ITEMS = 10;
 /**
- * Model selector - now a thin wrapper around BaseSelector
- * Provides data fetching and formatting only
+ * Model selector with search and custom model support
  */
-export default function ModelSelector({ isVisible, onSelectModel, onClose, agent, }) {
+const ModelSelector = forwardRef(function ModelSelector({ isVisible, onSelectModel, onClose, onAddCustomModel, onEditCustomModel, agent }, ref) {
     const [models, setModels] = useState([]);
+    const [customModels, setCustomModels] = useState([]);
     const [isLoading, setIsLoading] = useState(false);
     const [selectedIndex, setSelectedIndex] = useState(0);
-    // Fetch models from agent
+    const [searchQuery, setSearchQuery] = useState('');
+    const [scrollOffset, setScrollOffset] = useState(0);
+    const [customModelAction, setCustomModelAction] = useState(null);
+    const [pendingDeleteConfirm, setPendingDeleteConfirm] = useState(false);
+    const selectedIndexRef = useRef(selectedIndex);
+    const deleteTimeoutRef = useRef(null);
+    // Keep ref in sync
+    selectedIndexRef.current = selectedIndex;
+    // Clear delete confirmation timeout on unmount
+    useEffect(() => {
+        return () => {
+            if (deleteTimeoutRef.current) {
+                clearTimeout(deleteTimeoutRef.current);
+            }
+        };
+    }, []);
+    // Fetch models from agent and load custom models
     useEffect(() => {
         if (!isVisible)
             return;
         let cancelled = false;
         setIsLoading(true);
+        setSearchQuery('');
+        setSelectedIndex(0);
+        setScrollOffset(0);
+        setCustomModelAction(null);
+        setPendingDeleteConfirm(false);
+        if (deleteTimeoutRef.current) {
+            clearTimeout(deleteTimeoutRef.current);
+            deleteTimeoutRef.current = null;
+        }
         const fetchModels = async () => {
             try {
-                const allModels = agent.getSupportedModels();
-                const providers = agent.getSupportedProviders();
-                const currentConfig = agent.getCurrentLLMConfig();
+                const [allModels, providers, currentConfig, loadedCustomModels] = await Promise.all([
+                    Promise.resolve(agent.getSupportedModels()),
+                    Promise.resolve(agent.getSupportedProviders()),
+                    Promise.resolve(agent.getCurrentLLMConfig()),
+                    loadCustomModels(),
+                ]);
                 const modelList = [];
+                // Fetch dynamic models for local providers
+                let ollamaModels = [];
+                let localModels = [];
+                try {
+                    ollamaModels = await listOllamaModels(DEFAULT_OLLAMA_URL);
+                }
+                catch (error) {
+                    // Ollama not available, skip
+                    agent.logger.debug('Ollama not available for model listing');
+                }
+                try {
+                    localModels = await getAllInstalledModels();
+                }
+                catch (error) {
+                    // Local models not available, skip
+                    agent.logger.debug('Local models not available for listing');
+                }
+                // Add custom models first
+                for (const custom of loadedCustomModels) {
+                    // Use provider from custom model, default to openai-compatible for legacy models
+                    const customProvider = (custom.provider ?? 'openai-compatible');
+                    const modelOption = {
+                        provider: customProvider,
+                        name: custom.name,
+                        displayName: custom.displayName || custom.name,
+                        maxInputTokens: custom.maxInputTokens || 128000,
+                        isDefault: false,
+                        isCurrent: currentConfig.provider === customProvider &&
+                            currentConfig.model === custom.name,
+                        isCustom: true,
+                    };
+                    if (custom.baseURL) {
+                        modelOption.baseURL = custom.baseURL;
+                    }
+                    modelList.push(modelOption);
+                }
+                // Add registry models
                 for (const provider of providers) {
+                    // Skip custom-only providers that don't have a static model list
+                    // These are only accessible via the "Add custom model" wizard
+                    if (provider === 'openai-compatible' ||
+                        provider === 'openrouter' ||
+                        provider === 'litellm' ||
+                        provider === 'glama' ||
+                        provider === 'bedrock')
+                        continue;
+                    // Skip ollama, local, and vertex - they'll be added dynamically below
+                    if (provider === 'ollama' || provider === 'local' || provider === 'vertex') {
+                        continue;
+                    }
                     const providerModels = allModels[provider];
                     for (const model of providerModels) {
                         modelList.push({
@@ -39,22 +121,70 @@ export default function ModelSelector({ isVisible, onSelectModel, onClose, agent
                             isDefault: model.isDefault,
                             isCurrent: provider === currentConfig.provider &&
                                 model.name === currentConfig.model,
+                            isCustom: false,
+                        });
+                    }
+                }
+                // Add Ollama models dynamically
+                for (const ollamaModel of ollamaModels) {
+                    modelList.push({
+                        provider: 'ollama',
+                        name: ollamaModel.name,
+                        displayName: ollamaModel.name,
+                        maxInputTokens: 128000, // Default, actual varies by model
+                        isDefault: false,
+                        isCurrent: currentConfig.provider === 'ollama' &&
+                            currentConfig.model === ollamaModel.name,
+                        isCustom: false,
+                    });
+                }
+                // Add local models dynamically
+                for (const localModel of localModels) {
+                    // Get display name from registry if available
+                    const modelInfo = getLocalModelById(localModel.id);
+                    const displayName = modelInfo?.name || localModel.id;
+                    const maxInputTokens = modelInfo?.contextLength || 128000;
+                    modelList.push({
+                        provider: 'local',
+                        name: localModel.id,
+                        displayName,
+                        maxInputTokens,
+                        isDefault: false,
+                        isCurrent: currentConfig.provider === 'local' &&
+                            currentConfig.model === localModel.id,
+                        isCustom: false,
+                    });
+                }
+                // Add Vertex AI models from registry
+                const vertexModels = allModels['vertex'];
+                if (vertexModels) {
+                    for (const model of vertexModels) {
+                        modelList.push({
+                            provider: 'vertex',
+                            name: model.name,
+                            displayName: model.displayName,
+                            maxInputTokens: model.maxInputTokens,
+                            isDefault: model.isDefault,
+                            isCurrent: currentConfig.provider === 'vertex' &&
+                                currentConfig.model === model.name,
+                            isCustom: false,
                         });
                     }
                 }
                 if (!cancelled) {
                     setModels(modelList);
+                    setCustomModels(loadedCustomModels);
                     setIsLoading(false);
-                    // Set initial selection to current model
+                    // Set initial selection to current model (offset by 1 for "Add custom" option)
                     const currentIndex = modelList.findIndex((m) => m.isCurrent);
                     if (currentIndex >= 0) {
-                        setSelectedIndex(currentIndex);
+                        setSelectedIndex(currentIndex + 1); // +1 for "Add custom" at top
                     }
                 }
             }
             catch (error) {
                 if (!cancelled) {
-                    logger.error(`Failed to fetch models: ${error instanceof Error ? error.message : 'Unknown error'}`, { error });
+                    agent.logger.error(`Failed to fetch models: ${error instanceof Error ? error.message : 'Unknown error'}`);
                     setModels([]);
                     setIsLoading(false);
                 }
@@ -65,11 +195,258 @@ export default function ModelSelector({ isVisible, onSelectModel, onClose, agent
             cancelled = true;
         };
     }, [isVisible, agent]);
-    // Format model item for display
-    const formatItem = (model, isSelected) => (_jsxs(_Fragment, { children: [_jsx(Text, { color: isSelected ? 'black' : 'gray', bold: isSelected, children: model.displayName || model.name }), _jsxs(Text, { color: isSelected ? 'black' : 'gray', dimColor: !isSelected, children: [' ', "(", model.provider, ")"] }), _jsxs(Text, { color: isSelected ? 'black' : 'gray', dimColor: !isSelected, children: [' ', "\u2022 ", model.maxInputTokens.toLocaleString(), " tokens"] }), model.isDefault && (_jsxs(Text, { color: isSelected ? 'black' : 'gray', dimColor: !isSelected, children: [' ', "[DEFAULT]"] })), model.isCurrent && (_jsxs(Text, { color: isSelected ? 'black' : 'gray', bold: isSelected, children: [' ', "\u2190 Current"] }))] }));
-    // Handle selection
-    const handleSelect = (model) => {
-        onSelectModel(model.provider, model.name);
+    // Filter models based on search query
+    const filteredItems = useMemo(() => {
+        const addCustomOption = { type: 'add-custom' };
+        if (!searchQuery.trim()) {
+            return [addCustomOption, ...models];
+        }
+        const query = searchQuery.toLowerCase();
+        const filtered = models.filter((model) => {
+            const name = model.name.toLowerCase();
+            const displayName = (model.displayName || '').toLowerCase();
+            const provider = model.provider.toLowerCase();
+            return name.includes(query) || displayName.includes(query) || provider.includes(query);
+        });
+        // Always show "Add custom" when searching (user might want to add what they're searching for)
+        return [addCustomOption, ...filtered];
+    }, [models, searchQuery]);
+    // Adjust selected index when filter changes
+    useEffect(() => {
+        if (selectedIndex >= filteredItems.length) {
+            setSelectedIndex(Math.max(0, filteredItems.length - 1));
+        }
+    }, [filteredItems.length, selectedIndex]);
+    // Calculate scroll offset
+    useEffect(() => {
+        if (selectedIndex < scrollOffset) {
+            setScrollOffset(selectedIndex);
+        }
+        else if (selectedIndex >= scrollOffset + MAX_VISIBLE_ITEMS) {
+            setScrollOffset(selectedIndex - MAX_VISIBLE_ITEMS + 1);
+        }
+    }, [selectedIndex, scrollOffset]);
+    // Handle delete custom model
+    const handleDeleteCustomModel = useCallback(async (model) => {
+        if (!model.isCustom)
+            return;
+        try {
+            await deleteCustomModel(model.name);
+            // Refresh the list
+            const updated = await loadCustomModels();
+            setCustomModels(updated);
+            // Update models list
+            setModels((prev) => prev.filter((m) => !(m.isCustom && m.name === model.name)));
+        }
+        catch (error) {
+            agent.logger.error(`Failed to delete custom model: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }, [agent]);
+    // Helper to clear action state
+    const clearActionState = () => {
+        setCustomModelAction(null);
+        setPendingDeleteConfirm(false);
+        if (deleteTimeoutRef.current) {
+            clearTimeout(deleteTimeoutRef.current);
+            deleteTimeoutRef.current = null;
+        }
     };
-    return (_jsx(BaseSelector, { items: models, isVisible: isVisible, isLoading: isLoading, selectedIndex: selectedIndex, onSelectIndex: setSelectedIndex, onSelect: handleSelect, onClose: onClose, formatItem: formatItem, title: "Select Model", borderColor: "cyan", loadingMessage: "Loading models...", emptyMessage: "No models found" }));
-}
+    // Expose handleInput method via ref
+    useImperativeHandle(ref, () => ({
+        handleInput: (input, key) => {
+            if (!isVisible)
+                return false;
+            // Escape always works
+            if (key.escape) {
+                // If in action mode, just clear it first
+                if (customModelAction) {
+                    clearActionState();
+                    return true;
+                }
+                onClose();
+                return true;
+            }
+            const itemsLength = filteredItems.length;
+            const currentItem = filteredItems[selectedIndexRef.current];
+            const isOnCustomModel = currentItem && !isAddCustomOption(currentItem) && currentItem.isCustom;
+            // Right arrow - enter/advance action mode for custom models
+            if (key.rightArrow) {
+                if (!isOnCustomModel)
+                    return false;
+                if (customModelAction === null) {
+                    // Enter edit mode
+                    setCustomModelAction('edit');
+                    return true;
+                }
+                else if (customModelAction === 'edit') {
+                    // Advance to delete mode
+                    setCustomModelAction('delete');
+                    setPendingDeleteConfirm(false);
+                    return true;
+                }
+                else if (customModelAction === 'delete') {
+                    // In delete mode, right arrow confirms deletion
+                    if (pendingDeleteConfirm) {
+                        // Second press - actually delete
+                        if (deleteTimeoutRef.current) {
+                            clearTimeout(deleteTimeoutRef.current);
+                            deleteTimeoutRef.current = null;
+                        }
+                        clearActionState();
+                        void handleDeleteCustomModel(currentItem);
+                    }
+                    else {
+                        // First press in delete mode - set pending confirmation
+                        setPendingDeleteConfirm(true);
+                        if (deleteTimeoutRef.current) {
+                            clearTimeout(deleteTimeoutRef.current);
+                        }
+                        deleteTimeoutRef.current = setTimeout(() => {
+                            setPendingDeleteConfirm(false);
+                            deleteTimeoutRef.current = null;
+                        }, 3000); // 3 second timeout
+                    }
+                    return true;
+                }
+            }
+            // Left arrow - go back in action mode
+            if (key.leftArrow) {
+                if (customModelAction === 'delete') {
+                    setCustomModelAction('edit');
+                    setPendingDeleteConfirm(false);
+                    if (deleteTimeoutRef.current) {
+                        clearTimeout(deleteTimeoutRef.current);
+                        deleteTimeoutRef.current = null;
+                    }
+                    return true;
+                }
+                else if (customModelAction === 'edit') {
+                    setCustomModelAction(null);
+                    return true;
+                }
+                return false;
+            }
+            // Handle character input for search
+            if (input && !key.return && !key.upArrow && !key.downArrow && !key.tab) {
+                // Any character input clears action state and adds to search
+                if (customModelAction) {
+                    clearActionState();
+                }
+                // Backspace
+                if (key.backspace || key.delete) {
+                    setSearchQuery((prev) => prev.slice(0, -1));
+                    return true;
+                }
+                // Regular character - add to search
+                if (input.length === 1 && input.charCodeAt(0) >= 32) {
+                    setSearchQuery((prev) => prev + input);
+                    setSelectedIndex(0);
+                    setScrollOffset(0);
+                    return true;
+                }
+            }
+            // Backspace when no other input
+            if (key.backspace || key.delete) {
+                setSearchQuery((prev) => prev.slice(0, -1));
+                return true;
+            }
+            if (itemsLength === 0)
+                return false;
+            if (key.upArrow) {
+                // Clear action state on vertical navigation
+                if (customModelAction) {
+                    clearActionState();
+                }
+                const nextIndex = (selectedIndexRef.current - 1 + itemsLength) % itemsLength;
+                setSelectedIndex(nextIndex);
+                selectedIndexRef.current = nextIndex;
+                return true;
+            }
+            if (key.downArrow) {
+                // Clear action state on vertical navigation
+                if (customModelAction) {
+                    clearActionState();
+                }
+                const nextIndex = (selectedIndexRef.current + 1) % itemsLength;
+                setSelectedIndex(nextIndex);
+                selectedIndexRef.current = nextIndex;
+                return true;
+            }
+            if (key.return && itemsLength > 0) {
+                const item = filteredItems[selectedIndexRef.current];
+                if (item) {
+                    if (isAddCustomOption(item)) {
+                        onAddCustomModel();
+                        return true;
+                    }
+                    // Handle action mode confirmations
+                    if (customModelAction === 'edit' && item.isCustom) {
+                        // Find the full custom model data
+                        const customModel = customModels.find((cm) => cm.name === item.name &&
+                            (cm.provider ?? 'openai-compatible') === item.provider);
+                        if (customModel) {
+                            onEditCustomModel(customModel);
+                        }
+                        return true;
+                    }
+                    if (customModelAction === 'delete' && item.isCustom) {
+                        if (pendingDeleteConfirm) {
+                            // Already confirmed, delete
+                            clearActionState();
+                            void handleDeleteCustomModel(item);
+                        }
+                        else {
+                            // Set pending confirmation
+                            setPendingDeleteConfirm(true);
+                            if (deleteTimeoutRef.current) {
+                                clearTimeout(deleteTimeoutRef.current);
+                            }
+                            deleteTimeoutRef.current = setTimeout(() => {
+                                setPendingDeleteConfirm(false);
+                                deleteTimeoutRef.current = null;
+                            }, 3000);
+                        }
+                        return true;
+                    }
+                    // Normal selection
+                    onSelectModel(item.provider, item.name, item.displayName, item.baseURL);
+                    return true;
+                }
+            }
+            return false;
+        },
+    }), [
+        isVisible,
+        filteredItems,
+        onClose,
+        onSelectModel,
+        onAddCustomModel,
+        onEditCustomModel,
+        customModelAction,
+        pendingDeleteConfirm,
+        customModels,
+        handleDeleteCustomModel,
+    ]);
+    if (!isVisible)
+        return null;
+    if (isLoading) {
+        return (_jsx(Box, { paddingX: 0, paddingY: 0, children: _jsx(Text, { color: "gray", children: "Loading models..." }) }));
+    }
+    const visibleItems = filteredItems.slice(scrollOffset, scrollOffset + MAX_VISIBLE_ITEMS);
+    const hasCustomModels = customModels.length > 0;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { paddingX: 0, paddingY: 0, children: _jsxs(Text, { color: "cyan", bold: true, children: ["Select Model (", selectedIndex + 1, "/", filteredItems.length, ")"] }) }), _jsxs(Box, { paddingX: 0, paddingY: 0, children: [_jsx(Text, { color: "gray", children: "\u2191\u2193 navigate, Enter select, Esc close" }), hasCustomModels && _jsx(Text, { color: "gray", children: ", \u2192\u2190 for custom actions" })] }), _jsxs(Box, { paddingX: 0, paddingY: 0, children: [_jsx(Text, { color: "gray", children: "\uD83D\uDD0D " }), _jsx(Text, { color: searchQuery ? 'white' : 'gray', children: searchQuery || 'Type to search...' }), _jsx(Text, { color: "cyan", children: "\u258C" })] }), _jsx(Box, { paddingX: 0, paddingY: 0, children: _jsx(Text, { color: "gray", children: '─'.repeat(50) }) }), visibleItems.map((item, visibleIndex) => {
+                const actualIndex = scrollOffset + visibleIndex;
+                const isSelected = actualIndex === selectedIndex;
+                if (isAddCustomOption(item)) {
+                    return (_jsx(Box, { paddingX: 0, paddingY: 0, children: _jsx(Text, { color: isSelected ? 'green' : 'gray', bold: isSelected, children: "\u2795 Add custom model..." }) }, "add-custom"));
+                }
+                // Show action buttons for selected custom models
+                const showActions = isSelected && item.isCustom;
+                return (_jsxs(Box, { paddingX: 0, paddingY: 0, children: [item.isCustom && _jsx(Text, { color: isSelected ? 'orange' : 'gray', children: "\u2605 " }), _jsx(Text, { color: isSelected ? 'cyan' : 'gray', bold: isSelected, children: item.displayName || item.name }), _jsxs(Text, { color: isSelected ? 'white' : 'gray', children: [" (", item.provider, ")"] }), _jsxs(Text, { color: isSelected ? 'white' : 'gray', children: [' ', "\u2022 ", item.maxInputTokens.toLocaleString(), " tokens"] }), item.isDefault && (_jsx(Text, { color: isSelected ? 'white' : 'gray', children: " [DEFAULT]" })), item.isCurrent && !showActions && (_jsxs(Text, { color: isSelected ? 'cyan' : 'gray', bold: isSelected, children: [' ', "\u2190 Current"] })), showActions && (_jsxs(_Fragment, { children: [_jsx(Text, { children: " " }), _jsxs(Text, { color: customModelAction === 'edit' ? 'green' : 'gray', bold: customModelAction === 'edit', inverse: customModelAction === 'edit', children: [' ', "Edit", ' '] }), _jsx(Text, { children: " " }), _jsxs(Text, { color: customModelAction === 'delete' ? 'red' : 'gray', bold: customModelAction === 'delete', inverse: customModelAction === 'delete', children: [' ', "Delete", ' '] })] }))] }, `${item.provider}-${item.name}`));
+            }), filteredItems.length > MAX_VISIBLE_ITEMS && (_jsx(Box, { paddingX: 0, paddingY: 0, children: _jsxs(Text, { color: "gray", children: [scrollOffset > 0 ? '↑ more above' : '', scrollOffset > 0 && scrollOffset + MAX_VISIBLE_ITEMS < filteredItems.length
+                            ? ' | '
+                            : '', scrollOffset + MAX_VISIBLE_ITEMS < filteredItems.length
+                            ? '↓ more below'
+                            : ''] }) })), customModelAction === 'delete' && pendingDeleteConfirm && (_jsx(Box, { paddingX: 0, paddingY: 0, marginTop: 1, children: _jsx(Text, { color: "yellowBright", children: "\u26A0\uFE0F Press \u2192 or Enter again to confirm delete" }) })), customModelAction && !pendingDeleteConfirm && (_jsx(Box, { paddingX: 0, paddingY: 0, marginTop: 1, children: _jsxs(Text, { color: "gray", children: ["\u2190 ", customModelAction === 'edit' ? 'deselect' : 'edit', " | \u2192", ' ', customModelAction === 'edit' ? 'delete' : 'confirm', " | Enter", ' ', customModelAction] }) }))] }));
+});
+export default ModelSelector;

package/dist/cli/ink-cli/components/overlays/PromptAddChoice.d.ts

@@ -0,0 +1,22 @@
+/**
+ * PromptAddChoice Component
+ * Choose between adding a per-agent prompt or a shared prompt
+ */
+import React from 'react';
+import type { Key } from '../../hooks/useInputOrchestrator.js';
+import type { PromptAddScope } from '../../state/types.js';
+export type PromptAddChoiceResult = PromptAddScope | 'back';
+interface PromptAddChoiceProps {
+    isVisible: boolean;
+    onSelect: (choice: PromptAddChoiceResult) => void;
+    onClose: () => void;
+}
+export interface PromptAddChoiceHandle {
+    handleInput: (input: string, key: Key) => boolean;
+}
+/**
+ * PromptAddChoice - select scope for new prompt
+ */
+declare const PromptAddChoice: React.ForwardRefExoticComponent<PromptAddChoiceProps & React.RefAttributes<PromptAddChoiceHandle>>;
+export default PromptAddChoice;
+//# sourceMappingURL=PromptAddChoice.d.ts.map

package/dist/cli/ink-cli/components/overlays/PromptAddChoice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PromptAddChoice.d.ts","sourceRoot":"","sources":["../../../../../src/cli/ink-cli/components/overlays/PromptAddChoice.tsx"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAuE,MAAM,OAAO,CAAC;AAE5F,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,qCAAqC,CAAC;AAE/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D,MAAM,MAAM,qBAAqB,GAAG,cAAc,GAAG,MAAM,CAAC;AAE5D,UAAU,oBAAoB;IAC1B,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,CAAC,MAAM,EAAE,qBAAqB,KAAK,IAAI,CAAC;IAClD,OAAO,EAAE,MAAM,IAAI,CAAC;CACvB;AAED,MAAM,WAAW,qBAAqB;IAClC,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC;CACrD;AA0BD;;GAEG;AACH,QAAA,MAAM,eAAe,oGA2DpB,CAAC;AAEF,eAAe,eAAe,CAAC"}

package/dist/cli/ink-cli/components/overlays/PromptAddChoice.js

@@ -0,0 +1,52 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * PromptAddChoice Component
+ * Choose between adding a per-agent prompt or a shared prompt
+ */
+import { useState, useEffect, forwardRef, useRef, useImperativeHandle } from 'react';
+import { Box, Text } from 'ink';
+import { BaseSelector } from '../base/BaseSelector.js';
+const CHOICES = [
+    {
+        id: 'agent',
+        scope: 'agent',
+        label: 'For this agent only',
+        description: 'Stored in agent config directory',
+        recommended: true,
+    },
+    {
+        id: 'shared',
+        scope: 'shared',
+        label: 'For all agents (shared)',
+        description: 'Stored in ~/.dexto/commands/',
+    },
+];
+/**
+ * PromptAddChoice - select scope for new prompt
+ */
+const PromptAddChoice = forwardRef(function PromptAddChoice({ isVisible, onSelect, onClose }, ref) {
+    const baseSelectorRef = useRef(null);
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    // Reset selection when becoming visible
+    useEffect(() => {
+        if (isVisible) {
+            setSelectedIndex(0);
+        }
+    }, [isVisible]);
+    // Forward handleInput to BaseSelector
+    useImperativeHandle(ref, () => ({
+        handleInput: (input, key) => {
+            return baseSelectorRef.current?.handleInput(input, key) ?? false;
+        },
+    }), []);
+    // Format item for display
+    const formatItem = (item, isSelected) => {
+        return (_jsxs(Box, { children: [_jsx(Text, { color: isSelected ? 'cyan' : 'white', bold: isSelected, children: item.label }), item.recommended && (_jsx(Text, { color: isSelected ? 'green' : 'gray', children: " (Recommended)" })), _jsxs(Text, { color: "gray", children: [" \u00B7 ", item.description] })] }));
+    };
+    // Handle selection
+    const handleSelect = (item) => {
+        onSelect(item.scope);
+    };
+    return (_jsx(BaseSelector, { ref: baseSelectorRef, items: CHOICES, isVisible: isVisible, selectedIndex: selectedIndex, onSelectIndex: setSelectedIndex, onSelect: handleSelect, onClose: onClose, formatItem: formatItem, title: "Add Prompt", borderColor: "yellowBright", emptyMessage: "No options available" }));
+});
+export default PromptAddChoice;

package/dist/cli/ink-cli/components/overlays/PromptAddWizard.d.ts

@@ -0,0 +1,29 @@
+/**
+ * PromptAddWizard Component
+ * Multi-step wizard for creating a new prompt
+ */
+import React from 'react';
+import type { Key } from '../../hooks/useInputOrchestrator.js';
+import type { PromptAddScope } from '../../state/types.js';
+export interface NewPromptData {
+    name: string;
+    title?: string;
+    description?: string;
+    argumentHint?: string;
+    content: string;
+}
+interface PromptAddWizardProps {
+    isVisible: boolean;
+    scope: PromptAddScope;
+    onComplete: (data: NewPromptData) => void;
+    onClose: () => void;
+}
+export interface PromptAddWizardHandle {
+    handleInput: (input: string, key: Key) => boolean;
+}
+/**
+ * Multi-step wizard for creating a new prompt
+ */
+declare const PromptAddWizard: React.ForwardRefExoticComponent<PromptAddWizardProps & React.RefAttributes<PromptAddWizardHandle>>;
+export default PromptAddWizard;
+//# sourceMappingURL=PromptAddWizard.d.ts.map

package/dist/cli/ink-cli/components/overlays/PromptAddWizard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PromptAddWizard.d.ts","sourceRoot":"","sources":["../../../../../src/cli/ink-cli/components/overlays/PromptAddWizard.tsx"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAA4E,MAAM,OAAO,CAAC;AAEjG,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,qCAAqC,CAAC;AAC/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D,MAAM,WAAW,aAAa;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;CACnB;AAuDD,UAAU,oBAAoB;IAC1B,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,cAAc,CAAC;IACtB,UAAU,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,IAAI,CAAC;IAC1C,OAAO,EAAE,MAAM,IAAI,CAAC;CACvB;AAED,MAAM,WAAW,qBAAqB;IAClC,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC;CACrD;AAED;;GAEG;AACH,QAAA,MAAM,eAAe,oGAuLpB,CAAC;AAEF,eAAe,eAAe,CAAC"}