@involvex/prompt-enhancer 0.0.2

package/dist/lib/enhancement/engine.js

@@ -0,0 +1,163 @@
+/**
+ * Enhancement engine - orchestrates prompt enhancement across providers
+ */
+import { getProvider } from '../providers/index.js';
+export class EnhancementEngine {
+    configManager;
+    historyManager;
+    constructor(configManager, historyManager) {
+        this.configManager = configManager;
+        this.historyManager = historyManager;
+    }
+    /**
+     * Enhance a prompt using the specified (or default) provider
+     */
+    async enhance(request) {
+        const startTime = Date.now();
+        const config = this.configManager.getConfig();
+        // Determine which provider to use
+        const providerName = request.provider || config.defaultProvider;
+        const providerConfig = config.providers[providerName];
+        if (!providerConfig?.enabled) {
+            throw new Error(`Provider '${providerName}' is not enabled. Please configure it in settings.`);
+        }
+        // Create credentials from config
+        const credentials = {
+            apiKey: providerConfig.apiKey || '',
+            endpoint: providerConfig.endpoint,
+        };
+        const provider = getProvider(providerName, credentials);
+        if (!provider) {
+            throw new Error(`Provider '${providerName}' not found. Available providers: ${Object.keys(config.providers).join(', ')}`);
+        }
+        // Create enhancement options
+        const options = {
+            model: request.model || config.defaultModel,
+            temperature: request.temperature ?? config.temperature,
+            maxTokens: request.maxTokens ?? config.maxTokens,
+        };
+        // Enhance the prompt
+        let enhanced;
+        try {
+            enhanced = await provider.enhance(request.prompt, options);
+        }
+        catch (error) {
+            throw new Error(`Enhancement failed with ${providerName}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const duration = Date.now() - startTime;
+        // Save to history if requested
+        if (request.saveToHistory !== false && config.saveHistory) {
+            await this.historyManager.addEntry({
+                originalPrompt: request.prompt,
+                enhancedPrompt: enhanced,
+                provider: providerName,
+                model: options.model || 'default',
+                temperature: options.temperature,
+                tokens: options.maxTokens,
+            });
+        }
+        return {
+            originalPrompt: request.prompt,
+            enhancedPrompt: enhanced,
+            provider: providerName,
+            model: options.model || 'default',
+            duration,
+        };
+    }
+    /**
+     * Enhance a prompt with streaming output
+     */
+    async *enhanceStream(request) {
+        const startTime = Date.now();
+        const config = this.configManager.getConfig();
+        // Determine which provider to use
+        const providerName = request.provider || config.defaultProvider;
+        const providerConfig = config.providers[providerName];
+        if (!providerConfig?.enabled) {
+            throw new Error(`Provider '${providerName}' is not enabled. Please configure it in settings.`);
+        }
+        // Create credentials from config
+        const credentials = {
+            apiKey: providerConfig.apiKey || '',
+            endpoint: providerConfig.endpoint,
+        };
+        const provider = getProvider(providerName, credentials);
+        if (!provider) {
+            throw new Error(`Provider '${providerName}' not found. Available providers: ${Object.keys(config.providers).join(', ')}`);
+        }
+        // Create enhancement options
+        const options = {
+            model: request.model || config.defaultModel,
+            temperature: request.temperature ?? config.temperature,
+            maxTokens: request.maxTokens ?? config.maxTokens,
+        };
+        // Stream enhancement
+        let enhancedText = '';
+        try {
+            for await (const chunk of provider.enhanceStream(request.prompt, options)) {
+                enhancedText += chunk;
+                yield chunk;
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new Error(`Enhancement failed with ${providerName}: ${errorMessage}`);
+        }
+        const duration = Date.now() - startTime;
+        // Save to history if requested
+        if (request.saveToHistory !== false && config.saveHistory) {
+            await this.historyManager.addEntry({
+                originalPrompt: request.prompt,
+                enhancedPrompt: enhancedText,
+                provider: providerName,
+                model: options.model || 'default',
+                temperature: options.temperature,
+                tokens: options.maxTokens,
+            });
+        }
+        return {
+            originalPrompt: request.prompt,
+            enhancedPrompt: enhancedText,
+            provider: providerName,
+            model: options.model || 'default',
+            duration,
+        };
+    }
+    /**
+     * Get available models for a provider
+     */
+    async getAvailableModels(providerName) {
+        const config = this.configManager.getConfig();
+        const providers = providerName
+            ? [providerName]
+            : Object.keys(config.providers);
+        const result = {};
+        for (const pName of providers) {
+            const provider = getProvider(pName);
+            if (provider) {
+                try {
+                    result[pName] = await provider.getAvailableModels();
+                }
+                catch {
+                    result[pName] = []; // Return empty list on error
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Validate provider credentials
+     */
+    async validateProvider(providerName) {
+        const provider = getProvider(providerName);
+        if (!provider) {
+            return false;
+        }
+        try {
+            return await provider.validateCredentials();
+        }
+        catch {
+            return false;
+        }
+    }
+}

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

@@ -0,0 +1,45 @@
+/**
+ * History manager for persisting enhanced prompts
+ */
+import type { HistoryEntry, HistoryData } from '../config/schema.js';
+export declare class HistoryManager {
+    private history;
+    private historyPath;
+    constructor(historyPath?: string);
+    /**
+     * Load history from file
+     */
+    load(): Promise<HistoryData>;
+    /**
+     * Save current history to file
+     */
+    save(): Promise<void>;
+    /**
+     * Add an entry to history
+     */
+    addEntry(entry: Omit<HistoryEntry, 'id' | 'timestamp'>): Promise<HistoryEntry>;
+    /**
+     * Get all history entries
+     */
+    getEntries(): HistoryEntry[];
+    /**
+     * Get entries by provider
+     */
+    getEntriesByProvider(provider: string): HistoryEntry[];
+    /**
+     * Get recent entries (last N)
+     */
+    getRecent(count?: number): HistoryEntry[];
+    /**
+     * Clear all history
+     */
+    clear(): Promise<void>;
+    /**
+     * Delete a specific entry
+     */
+    deleteEntry(id: string): Promise<boolean>;
+    /**
+     * Export history as JSON
+     */
+    export(): HistoryData;
+}

package/dist/lib/history/manager.js

@@ -0,0 +1,120 @@
+/**
+ * History manager for persisting enhanced prompts
+ */
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import { randomUUID } from 'crypto';
+import { HistoryDataSchema } from '../config/schema.js';
+import { CONFIG_DIR, HISTORY_FILE } from '../utils/paths.js';
+const DEFAULT_HISTORY = {
+    entries: [],
+    version: '1.0.0',
+};
+export class HistoryManager {
+    history;
+    historyPath;
+    constructor(historyPath) {
+        this.historyPath = historyPath || HISTORY_FILE;
+        this.history = structuredClone(DEFAULT_HISTORY);
+    }
+    /**
+     * Load history from file
+     */
+    async load() {
+        try {
+            // Ensure directory exists
+            if (!existsSync(CONFIG_DIR)) {
+                await mkdir(CONFIG_DIR, { recursive: true });
+            }
+            // If history file doesn't exist, create it with defaults
+            if (!existsSync(this.historyPath)) {
+                await this.save();
+                return this.history;
+            }
+            // Read and parse history file
+            const content = await readFile(this.historyPath, 'utf-8');
+            const parsed = JSON.parse(content);
+            // Validate using schema
+            const validated = HistoryDataSchema.parse(parsed);
+            this.history = validated;
+            return this.history;
+        }
+        catch (error) {
+            console.error('Failed to load history:', error);
+            throw error;
+        }
+    }
+    /**
+     * Save current history to file
+     */
+    async save() {
+        try {
+            // Ensure directory exists
+            if (!existsSync(CONFIG_DIR)) {
+                await mkdir(CONFIG_DIR, { recursive: true });
+            }
+            // Write history file
+            await writeFile(this.historyPath, JSON.stringify(this.history, null, 2), 'utf-8');
+        }
+        catch (error) {
+            console.error('Failed to save history:', error);
+            throw error;
+        }
+    }
+    /**
+     * Add an entry to history
+     */
+    async addEntry(entry) {
+        const historyEntry = {
+            ...entry,
+            id: randomUUID(),
+            timestamp: Date.now(),
+        };
+        this.history.entries.push(historyEntry);
+        await this.save();
+        return historyEntry;
+    }
+    /**
+     * Get all history entries
+     */
+    getEntries() {
+        return this.history.entries;
+    }
+    /**
+     * Get entries by provider
+     */
+    getEntriesByProvider(provider) {
+        return this.history.entries.filter(entry => entry.provider === provider);
+    }
+    /**
+     * Get recent entries (last N)
+     */
+    getRecent(count = 10) {
+        return this.history.entries.slice(-count).reverse();
+    }
+    /**
+     * Clear all history
+     */
+    async clear() {
+        this.history.entries = [];
+        await this.save();
+    }
+    /**
+     * Delete a specific entry
+     */
+    async deleteEntry(id) {
+        const index = this.history.entries.findIndex(e => e.id === id);
+        if (index !== -1) {
+            this.history.entries.splice(index, 1);
+            await this.save();
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Export history as JSON
+     */
+    export() {
+        return structuredClone(this.history);
+    }
+}

package/dist/lib/providers/base.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Abstract base class for all LLM providers
+ * Defines the interface that all provider implementations must follow
+ */
+import type { EnhancementOptions, ProviderCredentials } from '../types/index.js';
+export declare abstract class Provider {
+    protected name: string;
+    protected credentials: ProviderCredentials;
+    protected defaultModel: string;
+    constructor(name: string, credentials: ProviderCredentials, defaultModel: string);
+    /**
+     * Get the provider name
+     */
+    getName(): string;
+    /**
+     * Enhance a prompt using this provider
+     * @param prompt The prompt to enhance
+     * @param options Enhancement options (model, temperature, etc.)
+     * @returns The enhanced prompt as a string
+     */
+    abstract enhance(prompt: string, options?: EnhancementOptions): Promise<string>;
+    /**
+     * Enhance a prompt with streaming output
+     * @param prompt The prompt to enhance
+     * @param options Enhancement options
+     * @returns AsyncGenerator that yields string chunks as they arrive
+     */
+    abstract enhanceStream(prompt: string, options?: EnhancementOptions): AsyncGenerator<string, void, unknown>;
+    /**
+     * Get available models for this provider
+     * @returns Array of available model IDs
+     */
+    abstract getAvailableModels(): Promise<string[]>;
+    /**
+     * Validate that the provider has valid credentials
+     * @returns true if credentials are valid, false otherwise
+     */
+    abstract validateCredentials(): Promise<boolean>;
+    /**
+     * Get provider-specific metadata
+     */
+    getMetadata(): {
+        name: string;
+        defaultModel: string;
+        supportsStreaming: boolean;
+    };
+}

package/dist/lib/providers/base.js

@@ -0,0 +1,30 @@
+/**
+ * Abstract base class for all LLM providers
+ * Defines the interface that all provider implementations must follow
+ */
+export class Provider {
+    name;
+    credentials;
+    defaultModel;
+    constructor(name, credentials, defaultModel) {
+        this.name = name;
+        this.credentials = credentials;
+        this.defaultModel = defaultModel;
+    }
+    /**
+     * Get the provider name
+     */
+    getName() {
+        return this.name;
+    }
+    /**
+     * Get provider-specific metadata
+     */
+    getMetadata() {
+        return {
+            name: this.name,
+            defaultModel: this.defaultModel,
+            supportsStreaming: true,
+        };
+    }
+}

package/dist/lib/providers/copilot.d.ts

@@ -0,0 +1,18 @@
+/**
+ * GitHub Copilot provider implementation
+ * Uses OpenAI-compatible API.
+ * Auto-detects OAuth token from ~/.copilot/ and other well-known paths;
+ * falls back to manually-configured apiKey.
+ */
+import { Provider } from './base.js';
+import type { EnhancementOptions, ProviderCredentials } from '../types/index.js';
+export declare class CopilotProvider extends Provider {
+    private client;
+    private initialized;
+    constructor(credentials: ProviderCredentials);
+    private ensureInitialized;
+    enhance(prompt: string, options?: EnhancementOptions): Promise<string>;
+    enhanceStream(prompt: string, options?: EnhancementOptions): AsyncGenerator<string, void, unknown>;
+    getAvailableModels(): Promise<string[]>;
+    validateCredentials(): Promise<boolean>;
+}

package/dist/lib/providers/copilot.js

@@ -0,0 +1,112 @@
+/**
+ * GitHub Copilot provider implementation
+ * Uses OpenAI-compatible API.
+ * Auto-detects OAuth token from ~/.copilot/ and other well-known paths;
+ * falls back to manually-configured apiKey.
+ */
+import { OpenAI } from 'openai';
+import { Provider } from './base.js';
+import { getCopilotToken } from '../utils/copilot-auth.js';
+export class CopilotProvider extends Provider {
+    client;
+    initialized = false;
+    constructor(credentials) {
+        super('copilot', credentials, 'gpt-4o');
+        // Async init happens in ensureInitialized() before first use
+    }
+    async ensureInitialized() {
+        if (this.initialized)
+            return;
+        let apiKey = this.credentials.apiKey;
+        // Try auto-detection if no key was manually provided
+        if (!apiKey || this.credentials.useOAuth) {
+            const autoToken = await getCopilotToken();
+            if (autoToken) {
+                apiKey = autoToken;
+            }
+        }
+        if (!apiKey) {
+            throw new Error('Copilot provider: no API key found. Set an API key in settings or install GitHub Copilot / GitHub CLI so a token can be auto-detected.');
+        }
+        const config = { apiKey };
+        if (this.credentials.endpoint) {
+            config.baseURL = this.credentials.endpoint;
+        }
+        this.client = new OpenAI(config);
+        this.initialized = true;
+    }
+    async enhance(prompt, options) {
+        await this.ensureInitialized();
+        const systemPrompt = options?.systemPrompt ||
+            'You are an expert at enhancing and improving user prompts for LLMs. Analyze the given prompt and return an improved version that is clearer, more specific, and more likely to produce better results. Return ONLY the enhanced prompt, no explanations.';
+        const response = await this.client.chat.completions.create({
+            messages: [
+                {
+                    role: 'system',
+                    content: systemPrompt,
+                },
+                {
+                    role: 'user',
+                    content: `Original prompt:\n${prompt}`,
+                },
+            ],
+            model: options?.model || this.defaultModel,
+            temperature: options?.temperature || 0.7,
+            max_tokens: options?.maxTokens || 1000,
+        });
+        const content = response.choices[0]?.message?.content;
+        if (!content) {
+            throw new Error('No response received from Copilot');
+        }
+        return content.trim();
+    }
+    async *enhanceStream(prompt, options) {
+        await this.ensureInitialized();
+        const systemPrompt = options?.systemPrompt ||
+            'You are an expert at enhancing and improving user prompts for LLMs. Analyze the given prompt and return an improved version that is clearer, more specific, and more likely to produce better results. Return ONLY the enhanced prompt, no explanations.';
+        const stream = await this.client.chat.completions.create({
+            messages: [
+                {
+                    role: 'system',
+                    content: systemPrompt,
+                },
+                {
+                    role: 'user',
+                    content: `Original prompt:\n${prompt}`,
+                },
+            ],
+            model: options?.model || this.defaultModel,
+            temperature: options?.temperature || 0.7,
+            max_tokens: options?.maxTokens || 1000,
+            stream: true,
+        });
+        for await (const event of stream) {
+            const content = event.choices[0]?.delta?.content;
+            if (content) {
+                yield content;
+            }
+        }
+    }
+    async getAvailableModels() {
+        return ['gpt-4o', 'gpt-4o-mini', 'gpt-4.1', 'claude-sonnet-4', 'o3'];
+    }
+    async validateCredentials() {
+        try {
+            await this.ensureInitialized();
+            await this.client.chat.completions.create({
+                messages: [
+                    {
+                        role: 'user',
+                        content: 'test',
+                    },
+                ],
+                model: this.defaultModel,
+                max_tokens: 1,
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/lib/providers/gemini.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Google Gemini provider implementation
+ */
+import { Provider } from './base.js';
+import type { EnhancementOptions, ProviderCredentials } from '../types/index.js';
+export declare class GeminiProvider extends Provider {
+    private client;
+    constructor(credentials: ProviderCredentials);
+    enhance(prompt: string, options?: EnhancementOptions): Promise<string>;
+    enhanceStream(prompt: string, options?: EnhancementOptions): AsyncGenerator<string, void, unknown>;
+    getAvailableModels(): Promise<string[]>;
+    validateCredentials(): Promise<boolean>;
+}

package/dist/lib/providers/gemini.js

@@ -0,0 +1,86 @@
+/**
+ * Google Gemini provider implementation
+ */
+import { GoogleGenerativeAI } from '@google/generative-ai';
+import { Provider } from './base.js';
+export class GeminiProvider extends Provider {
+    client;
+    constructor(credentials) {
+        super('gemini', credentials, 'gemini-2.5-flash');
+        if (!credentials.apiKey) {
+            throw new Error('Gemini provider requires an API key');
+        }
+        this.client = new GoogleGenerativeAI(credentials.apiKey);
+    }
+    async enhance(prompt, options) {
+        const model = this.client.getGenerativeModel({
+            model: options?.model || this.defaultModel,
+        });
+        const systemPrompt = options?.systemPrompt ||
+            'You are an expert at enhancing and improving user prompts for LLMs. Analyze the given prompt and return an improved version that is clearer, more specific, and more likely to produce better results. Return ONLY the enhanced prompt, no explanations.';
+        const result = await model.generateContent({
+            contents: [
+                {
+                    role: 'user',
+                    parts: [
+                        {
+                            text: `${systemPrompt}\n\nOriginal prompt:\n${prompt}`,
+                        },
+                    ],
+                },
+            ],
+        });
+        const response = result.response;
+        const text = response.text();
+        if (!text) {
+            throw new Error('No response received from Gemini');
+        }
+        return text.trim();
+    }
+    async *enhanceStream(prompt, options) {
+        const model = this.client.getGenerativeModel({
+            model: options?.model || this.defaultModel,
+        });
+        const systemPrompt = options?.systemPrompt ||
+            'You are an expert at enhancing and improving user prompts for LLMs. Analyze the given prompt and return an improved version that is clearer, more specific, and more likely to produce better results. Return ONLY the enhanced prompt, no explanations.';
+        const result = await model.generateContentStream({
+            contents: [
+                {
+                    role: 'user',
+                    parts: [
+                        {
+                            text: `${systemPrompt}\n\nOriginal prompt:\n${prompt}`,
+                        },
+                    ],
+                },
+            ],
+        });
+        for await (const chunk of result.stream) {
+            const text = chunk.text();
+            if (text) {
+                yield text;
+            }
+        }
+    }
+    async getAvailableModels() {
+        // Gemini models available as of 2025
+        return [
+            'gemini-2.5-flash',
+            'gemini-2.0-flash',
+            'gemini-1.5-pro',
+            'gemini-1.5-flash',
+        ];
+    }
+    async validateCredentials() {
+        try {
+            const model = this.client.getGenerativeModel({
+                model: this.defaultModel,
+            });
+            await model.countTokens('test prompt');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/lib/providers/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Provider factory and registry
+ * Manages creation and registration of provider instances
+ */
+import { Provider } from './base.js';
+import type { ProviderCredentials } from '../types/index.js';
+export type ProviderType = 'gemini' | 'copilot' | 'kilo' | 'opencode';
+export declare class ProviderFactory {
+    private registry;
+    createProvider(type: ProviderType, credentials: ProviderCredentials): Provider;
+    registerProvider(name: string, provider: Provider): void;
+    getProvider(name: string): Provider | undefined;
+    getAllProviders(): Provider[];
+    hasProvider(name: string): boolean;
+    listProviders(): string[];
+    clearProviders(): void;
+}
+export declare const providerFactory: ProviderFactory;
+/**
+ * Get or create a provider by type with credentials
+ */
+export declare function getProvider(type: ProviderType, credentials?: ProviderCredentials): Provider;
+/**
+ * Get list of supported provider types
+ */
+export declare function getSupportedProviders(): ProviderType[];