@involvex/prompt-enhancer 0.0.2

package/dist/components/settings.js

@@ -0,0 +1,246 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+import TextInput from 'ink-text-input';
+import SelectInput from './select-input.js';
+import { ConfigManager } from '../lib/config/manager.js';
+import { getModelsForProvider } from '../lib/utils/models-cache.js';
+function getStep(provider, stepIndex, useOAuth) {
+    if (provider === 'copilot') {
+        if (stepIndex === 0)
+            return 'useOAuth';
+        if (stepIndex === 1 && !useOAuth)
+            return 'apiKey';
+        return 'model';
+    }
+    return stepIndex === 0 ? 'apiKey' : 'model';
+}
+export default function Settings({ onBack }) {
+    const [state, setState] = useState('menu');
+    const [selectedProvider, setSelectedProvider] = useState('');
+    const [apiKey, setApiKey] = useState('');
+    const [modelText, setModelText] = useState('');
+    const [useOAuth, setUseOAuth] = useState(false);
+    const [stepIndex, setStepIndex] = useState(0);
+    const [message, setMessage] = useState('');
+    const [config, setConfig] = useState(null);
+    const [models, setModels] = useState([]);
+    const [modelsLoading, setModelsLoading] = useState(false);
+    useEffect(() => {
+        (async () => {
+            try {
+                const mgr = new ConfigManager();
+                await mgr.load();
+                setConfig(mgr.getConfig());
+            }
+            catch {
+                setMessage('Failed to load configuration');
+            }
+        })();
+    }, []);
+    useEffect(() => {
+        if (state === 'success') {
+            const t = setTimeout(() => onBack(), 2000);
+            return () => clearTimeout(t);
+        }
+        return undefined;
+    }, [state, onBack]);
+    const loadModels = async (provider, key) => {
+        setModelsLoading(true);
+        setModels([]);
+        try {
+            const entries = await getModelsForProvider(provider, key);
+            setModels(entries);
+        }
+        catch {
+            setModels([]);
+        }
+        finally {
+            setModelsLoading(false);
+        }
+    };
+    const advanceStep = (nextUseOAuth) => {
+        const nextIndex = stepIndex + 1;
+        const nextStep = getStep(selectedProvider, nextIndex, nextUseOAuth ?? useOAuth);
+        if (nextStep === 'model' && selectedProvider) {
+            void loadModels(selectedProvider, selectedProvider === 'opencode' ? apiKey : undefined);
+        }
+        setStepIndex(nextIndex);
+    };
+    const saveProvider = async (chosenModel) => {
+        try {
+            const mgr = new ConfigManager();
+            await mgr.load();
+            const cfg = mgr.getConfig();
+            const entry = {
+                name: selectedProvider,
+                enabled: true,
+                model: chosenModel,
+            };
+            if (selectedProvider === 'copilot') {
+                entry.useOAuth = useOAuth;
+                if (!useOAuth && apiKey.trim())
+                    entry.apiKey = apiKey.trim();
+            }
+            else if (apiKey.trim()) {
+                entry.apiKey = apiKey.trim();
+            }
+            const updated = {
+                ...cfg,
+                providers: {
+                    ...cfg.providers,
+                    [selectedProvider]: entry,
+                },
+            };
+            await mgr.setConfig(updated);
+            setConfig(updated);
+            setMessage(`✓ ${selectedProvider} configured successfully!`);
+            setState('success');
+        }
+        catch (err) {
+            setMessage(`Error: ${err instanceof Error ? err.message : String(err)}`);
+            setState('error');
+        }
+    };
+    const saveDefaultProvider = async (provider) => {
+        try {
+            const mgr = new ConfigManager();
+            await mgr.load();
+            const cfg = mgr.getConfig();
+            const updated = { ...cfg, defaultProvider: provider };
+            await mgr.setConfig(updated);
+            setConfig(updated);
+            setMessage(`✓ Default provider set to ${provider}`);
+            setState('success');
+        }
+        catch (err) {
+            setMessage(`Error: ${err instanceof Error ? err.message : String(err)}`);
+            setState('error');
+        }
+    };
+    const saveDefaultModel = async (model) => {
+        try {
+            const mgr = new ConfigManager();
+            await mgr.load();
+            const cfg = mgr.getConfig();
+            const updated = { ...cfg, defaultModel: model };
+            await mgr.setConfig(updated);
+            setConfig(updated);
+            setMessage(`✓ Default model set to ${model}`);
+            setState('success');
+        }
+        catch (err) {
+            setMessage(`Error: ${err instanceof Error ? err.message : String(err)}`);
+            setState('error');
+        }
+    };
+    const providers = ['gemini', 'copilot', 'kilo', 'opencode'];
+    const menuItems = [
+        ...providers.map(p => ({ label: `Configure ${p}`, value: p })),
+        { label: 'Set Default Provider', value: '__default-provider__' },
+        { label: 'Set Default Model', value: '__default-model__' },
+        { label: 'Back', value: '__back__' },
+    ];
+    if (state === 'menu') {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 2, children: [_jsx(Text, { bold: true, color: "cyan", children: "\u2699 Settings" }), config && (_jsxs(Text, { color: "gray", children: ["default: ", config.defaultProvider ?? 'kilo', " /", ' ', config.defaultModel ?? 'minimax/minimax-m2.5'] })), _jsx(Box, { marginY: 1, children: _jsx(SelectInput, { items: menuItems, onSelect: item => {
+                            if (item.value === '__back__') {
+                                onBack();
+                            }
+                            else if (item.value === '__default-provider__') {
+                                setState('set-default-provider');
+                            }
+                            else if (item.value === '__default-model__') {
+                                const p = config?.defaultProvider ?? 'kilo';
+                                void loadModels(p);
+                                setState('set-default-model');
+                            }
+                            else {
+                                setSelectedProvider(item.value);
+                                setApiKey('');
+                                setModelText('');
+                                setUseOAuth(false);
+                                setStepIndex(0);
+                                setModels([]);
+                                setMessage('');
+                                setState('configure-provider');
+                            }
+                        } }) })] }));
+    }
+    if (state === 'set-default-provider') {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 2, children: [_jsx(Text, { bold: true, color: "cyan", children: "Set Default Provider" }), _jsx(Box, { marginY: 1, children: _jsx(SelectInput, { items: providers.map(p => ({ label: p, value: p })), onSelect: item => void saveDefaultProvider(item.value) }) })] }));
+    }
+    if (state === 'set-default-model') {
+        const defaultProvider = config?.defaultProvider ?? 'kilo';
+        if (modelsLoading) {
+            return (_jsx(Box, { paddingX: 2, children: _jsxs(Text, { color: "yellow", children: ["Loading models for ", defaultProvider, "\u2026"] }) }));
+        }
+        if (models.length === 0) {
+            return (_jsxs(Box, { flexDirection: "column", paddingX: 2, children: [_jsxs(Text, { bold: true, color: "cyan", children: ["Set Default Model (", defaultProvider, ")"] }), _jsxs(Box, { marginY: 1, children: [_jsx(Text, { children: "Model ID: " }), _jsx(TextInput, { value: modelText, onChange: setModelText, onSubmit: () => {
+                                    if (modelText.trim())
+                                        void saveDefaultModel(modelText.trim());
+                                }, placeholder: "Enter model ID\u2026" })] })] }));
+        }
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 2, children: [_jsxs(Text, { bold: true, color: "cyan", children: ["Set Default Model (", defaultProvider, ")"] }), _jsx(Box, { marginY: 1, children: _jsx(SelectInput, { items: models.map(m => ({
+                            label: `${m.name}  (${m.id})`,
+                            value: m.id,
+                        })), onSelect: item => void saveDefaultModel(item.value) }) })] }));
+    }
+    if (state === 'configure-provider') {
+        const step = getStep(selectedProvider, stepIndex, useOAuth);
+        if (step === 'useOAuth') {
+            return (_jsxs(Box, { flexDirection: "column", paddingX: 2, children: [_jsx(Text, { bold: true, color: "cyan", children: "Configure copilot \u2014 Authentication" }), _jsx(Box, { marginY: 1, children: _jsx(SelectInput, { items: [
+                                {
+                                    label: 'Auto-detect token from ~/.copilot/ (recommended)',
+                                    value: 'auto',
+                                },
+                                { label: 'Enter API key manually', value: 'manual' },
+                            ], onSelect: item => {
+                                const auto = item.value === 'auto';
+                                setUseOAuth(auto);
+                                advanceStep(auto);
+                            } }) })] }));
+        }
+        if (step === 'apiKey') {
+            const isRequired = selectedProvider === 'gemini' || selectedProvider === 'opencode';
+            const hint = selectedProvider === 'kilo'
+                ? 'Free models still need an API key — get one at https://app.kilo.ai'
+                : selectedProvider === 'copilot'
+                    ? 'Enter your GitHub Copilot API key'
+                    : selectedProvider === 'opencode'
+                        ? 'Enter your OpenCode API key — get one at https://opencode.ai'
+                        : undefined;
+            return (_jsxs(Box, { flexDirection: "column", paddingX: 2, children: [_jsxs(Text, { bold: true, color: "cyan", children: ["Configure ", selectedProvider] }), hint && (_jsx(Text, { color: "gray", dimColor: true, children: hint })), _jsxs(Box, { marginY: 1, children: [_jsxs(Text, { children: ["API Key", isRequired ? '' : ' (optional)', ": "] }), _jsx(TextInput, { value: apiKey, onChange: setApiKey, onSubmit: () => {
+                                    if (isRequired && !apiKey.trim()) {
+                                        setMessage(`API key is required for ${selectedProvider}`);
+                                        return;
+                                    }
+                                    setMessage('');
+                                    advanceStep();
+                                }, placeholder: selectedProvider === 'kilo'
+                                    ? 'Skip or enter key…'
+                                    : 'Enter API key…', mask: "*" })] }), message && _jsx(Text, { color: "red", children: message })] }));
+        }
+        if (step === 'model') {
+            if (modelsLoading) {
+                return (_jsx(Box, { paddingX: 2, children: _jsxs(Text, { color: "yellow", children: ["Loading models for ", selectedProvider, "\u2026"] }) }));
+            }
+            if (models.length === 0) {
+                return (_jsxs(Box, { flexDirection: "column", paddingX: 2, children: [_jsxs(Text, { bold: true, color: "cyan", children: ["Configure ", selectedProvider, " \u2014 Model"] }), _jsxs(Box, { marginY: 1, children: [_jsx(Text, { children: "Model ID: " }), _jsx(TextInput, { value: modelText, onChange: setModelText, onSubmit: () => {
+                                        if (modelText.trim())
+                                            void saveProvider(modelText.trim());
+                                    }, placeholder: "Enter model ID\u2026" })] })] }));
+            }
+            return (_jsxs(Box, { flexDirection: "column", paddingX: 2, children: [_jsxs(Text, { bold: true, color: "cyan", children: ["Configure ", selectedProvider, " \u2014 Choose Model"] }), _jsx(Box, { marginY: 1, children: _jsx(SelectInput, { items: models.map(m => ({
+                                label: `${m.name}  (${m.id})`,
+                                value: m.id,
+                            })), onSelect: item => void saveProvider(item.value) }) })] }));
+        }
+    }
+    if (state === 'success') {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 2, children: [_jsx(Text, { color: "green", children: message }), _jsx(Text, {}), _jsx(Text, { color: "gray", children: "(returning to menu\u2026)" })] }));
+    }
+    if (state === 'error') {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 2, children: [_jsx(Text, { color: "red", children: message }), _jsx(Text, {}), _jsx(Text, { color: "gray", children: "(Press Ctrl+C to exit)" })] }));
+    }
+    return null;
+}

package/dist/lib/config/manager.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Configuration manager for reading and writing app config
+ */
+import type { AppConfig } from './schema.js';
+export declare class ConfigManager {
+    private config;
+    private configPath;
+    constructor(configPath?: string);
+    /**
+     * Load config from file, creating it if it doesn't exist
+     */
+    load(): Promise<AppConfig>;
+    /**
+     * Save current config to file
+     */
+    save(): Promise<void>;
+    /**
+     * Get the current config object
+     */
+    getConfig(): AppConfig;
+    /**
+     * Set the entire config object (and save)
+     */
+    setConfig(config: AppConfig): Promise<void>;
+    /**
+     * Update a specific setting
+     */
+    setSetting<K extends keyof AppConfig>(key: K, value: AppConfig[K]): void;
+    /**
+     * Get a specific setting
+     */
+    getSetting<K extends keyof AppConfig>(key: K): AppConfig[K];
+    /**
+     * Update provider config
+     */
+    setProvider(providerName: string, config: Partial<AppConfig['providers'][string]>): void;
+    /**
+     * Get provider config
+     */
+    getProvider(providerName: string): AppConfig['providers'][string] | undefined;
+    /**
+     * Get all enabled providers
+     */
+    getEnabledProviders(): string[];
+    /**
+     * Reset config to defaults
+     */
+    reset(): Promise<void>;
+}

package/dist/lib/config/manager.js

@@ -0,0 +1,152 @@
+/**
+ * Configuration manager for reading and writing app config
+ */
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import { AppConfigSchema } from './schema.js';
+import { CONFIG_DIR, CONFIG_FILE } from '../utils/paths.js';
+import { KILO_DEFAULT_ENDPOINT, KILO_DEFAULT_MODEL } from '../providers/kilo.js';
+import { OPENCODE_CHAT_ENDPOINT } from '../providers/opencode.js';
+const DEFAULT_CONFIG = {
+    version: '1.0.0',
+    defaultProvider: 'kilo',
+    defaultModel: KILO_DEFAULT_MODEL,
+    streaming: true,
+    saveHistory: true,
+    providers: {
+        gemini: {
+            name: 'gemini',
+            enabled: false,
+        },
+        copilot: {
+            name: 'copilot',
+            enabled: false,
+        },
+        kilo: {
+            name: 'kilo',
+            enabled: true,
+            endpoint: KILO_DEFAULT_ENDPOINT,
+        },
+        opencode: {
+            name: 'opencode',
+            enabled: false,
+            endpoint: OPENCODE_CHAT_ENDPOINT,
+        },
+    },
+    temperature: 0.7,
+    maxTokens: 1000,
+    theme: 'dark',
+};
+export class ConfigManager {
+    config;
+    configPath;
+    constructor(configPath) {
+        this.configPath = configPath || CONFIG_FILE;
+        this.config = structuredClone(DEFAULT_CONFIG);
+    }
+    /**
+     * Load config from file, creating it if it doesn't exist
+     */
+    async load() {
+        try {
+            // Ensure config directory exists
+            if (!existsSync(CONFIG_DIR)) {
+                await mkdir(CONFIG_DIR, { recursive: true });
+            }
+            // If config file doesn't exist, create it with defaults
+            if (!existsSync(this.configPath)) {
+                await this.save();
+                return this.config;
+            }
+            // Read and parse config file
+            const content = await readFile(this.configPath, 'utf-8');
+            const parsed = JSON.parse(content);
+            // Validate using schema
+            const validated = AppConfigSchema.parse(parsed);
+            this.config = validated;
+            return this.config;
+        }
+        catch (error) {
+            console.error('Failed to load config:', error);
+            throw error;
+        }
+    }
+    /**
+     * Save current config to file
+     */
+    async save() {
+        try {
+            // Ensure directory exists
+            if (!existsSync(CONFIG_DIR)) {
+                await mkdir(CONFIG_DIR, { recursive: true });
+            }
+            // Write config file
+            await writeFile(this.configPath, JSON.stringify(this.config, null, 2), 'utf-8');
+        }
+        catch (error) {
+            console.error('Failed to save config:', error);
+            throw error;
+        }
+    }
+    /**
+     * Get the current config object
+     */
+    getConfig() {
+        return this.config;
+    }
+    /**
+     * Set the entire config object (and save)
+     */
+    async setConfig(config) {
+        this.config = config;
+        await this.save();
+    }
+    /**
+     * Update a specific setting
+     */
+    setSetting(key, value) {
+        this.config[key] = value;
+    }
+    /**
+     * Get a specific setting
+     */
+    getSetting(key) {
+        return this.config[key];
+    }
+    /**
+     * Update provider config
+     */
+    setProvider(providerName, config) {
+        if (!this.config.providers[providerName]) {
+            this.config.providers[providerName] = {
+                name: providerName,
+                enabled: false,
+            };
+        }
+        this.config.providers[providerName] = {
+            ...this.config.providers[providerName],
+            ...config,
+        };
+    }
+    /**
+     * Get provider config
+     */
+    getProvider(providerName) {
+        return this.config.providers[providerName];
+    }
+    /**
+     * Get all enabled providers
+     */
+    getEnabledProviders() {
+        return Object.entries(this.config.providers)
+            .filter(([, config]) => config.enabled)
+            .map(([name]) => name);
+    }
+    /**
+     * Reset config to defaults
+     */
+    async reset() {
+        this.config = structuredClone(DEFAULT_CONFIG);
+        await this.save();
+    }
+}

package/dist/lib/config/schema.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Zod schemas for configuration validation
+ */
+import { z } from 'zod';
+export declare const ProviderConfigSchema: z.ZodObject<{
+    name: z.ZodEnum<{
+        gemini: "gemini";
+        copilot: "copilot";
+        kilo: "kilo";
+        opencode: "opencode";
+    }>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    endpoint: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodBoolean;
+    useOAuth: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const AppConfigSchema: z.ZodObject<{
+    version: z.ZodString;
+    defaultProvider: z.ZodString;
+    defaultModel: z.ZodOptional<z.ZodString>;
+    streaming: z.ZodBoolean;
+    saveHistory: z.ZodBoolean;
+    providers: z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodEnum<{
+            gemini: "gemini";
+            copilot: "copilot";
+            kilo: "kilo";
+            opencode: "opencode";
+        }>;
+        apiKey: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        endpoint: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodBoolean;
+        useOAuth: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    theme: z.ZodOptional<z.ZodEnum<{
+        dark: "dark";
+        light: "light";
+    }>>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const HistoryEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    timestamp: z.ZodNumber;
+    originalPrompt: z.ZodString;
+    enhancedPrompt: z.ZodString;
+    provider: z.ZodString;
+    model: z.ZodString;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    tokens: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const HistoryDataSchema: z.ZodObject<{
+    entries: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        timestamp: z.ZodNumber;
+        originalPrompt: z.ZodString;
+        enhancedPrompt: z.ZodString;
+        provider: z.ZodString;
+        model: z.ZodString;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        tokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    version: z.ZodString;
+}, z.core.$strip>;
+export type AppConfig = z.infer<typeof AppConfigSchema>;
+export type HistoryEntry = z.infer<typeof HistoryEntrySchema>;
+export type HistoryData = z.infer<typeof HistoryDataSchema>;

package/dist/lib/config/schema.js

@@ -0,0 +1,37 @@
+/**
+ * Zod schemas for configuration validation
+ */
+import { z } from 'zod';
+export const ProviderConfigSchema = z.object({
+    name: z.enum(['gemini', 'copilot', 'kilo', 'opencode']),
+    apiKey: z.string().optional(),
+    model: z.string().optional(),
+    endpoint: z.string().url().optional(),
+    enabled: z.boolean(),
+    useOAuth: z.boolean().optional(),
+});
+export const AppConfigSchema = z.object({
+    version: z.string(),
+    defaultProvider: z.string(),
+    defaultModel: z.string().optional(),
+    streaming: z.boolean(),
+    saveHistory: z.boolean(),
+    providers: z.record(z.string(), ProviderConfigSchema),
+    theme: z.enum(['dark', 'light']).optional(),
+    temperature: z.number().min(0).max(2).optional(),
+    maxTokens: z.number().min(1).optional(),
+});
+export const HistoryEntrySchema = z.object({
+    id: z.string(),
+    timestamp: z.number(),
+    originalPrompt: z.string(),
+    enhancedPrompt: z.string(),
+    provider: z.string(),
+    model: z.string(),
+    temperature: z.number().optional(),
+    tokens: z.number().optional(),
+});
+export const HistoryDataSchema = z.object({
+    entries: z.array(HistoryEntrySchema),
+    version: z.string(),
+});

package/dist/lib/config/types.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Configuration types for prompt-enhancer
+ */
+export interface ProviderConfig {
+    name: string;
+    apiKey?: string;
+    endpoint?: string;
+    enabled: boolean;
+}
+export interface AppConfig {
+    version: string;
+    defaultProvider: string;
+    defaultModel?: string;
+    streaming: boolean;
+    saveHistory: boolean;
+    providers: Record<string, ProviderConfig>;
+    theme?: 'dark' | 'light';
+    temperature?: number;
+    maxTokens?: number;
+}
+export interface HistoryEntry {
+    id: string;
+    timestamp: number;
+    originalPrompt: string;
+    enhancedPrompt: string;
+    provider: string;
+    model: string;
+    temperature?: number;
+    tokens?: number;
+}
+export interface HistoryData {
+    entries: HistoryEntry[];
+    version: string;
+}

package/dist/lib/config/types.js

@@ -0,0 +1,4 @@
+/**
+ * Configuration types for prompt-enhancer
+ */
+export {};

package/dist/lib/enhancement/engine.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Enhancement engine - orchestrates prompt enhancement across providers
+ */
+import { HistoryManager } from '../history/manager.js';
+import { ConfigManager } from '../config/manager.js';
+export interface EnhancementRequest {
+    prompt: string;
+    provider?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    saveToHistory?: boolean;
+}
+export interface EnhancementResponse {
+    originalPrompt: string;
+    enhancedPrompt: string;
+    provider: string;
+    model: string;
+    duration: number;
+}
+export declare class EnhancementEngine {
+    private configManager;
+    private historyManager;
+    constructor(configManager: ConfigManager, historyManager: HistoryManager);
+    /**
+     * Enhance a prompt using the specified (or default) provider
+     */
+    enhance(request: EnhancementRequest): Promise<EnhancementResponse>;
+    /**
+     * Enhance a prompt with streaming output
+     */
+    enhanceStream(request: EnhancementRequest): AsyncGenerator<string, EnhancementResponse>;
+    /**
+     * Get available models for a provider
+     */
+    getAvailableModels(providerName?: string): Promise<Record<string, string[]>>;
+    /**
+     * Validate provider credentials
+     */
+    validateProvider(providerName: string): Promise<boolean>;
+}