@involvex/prompt-enhancer 0.0.2

package/dist/lib/providers/index.js

@@ -0,0 +1,86 @@
+/**
+ * Provider factory and registry
+ * Manages creation and registration of provider instances
+ */
+import { GeminiProvider } from './gemini.js';
+import { CopilotProvider } from './copilot.js';
+import { KiloProvider } from './kilo.js';
+import { OpenCodeProvider } from './opencode.js';
+class ProviderRegistry {
+    providers = new Map();
+    register(name, provider) {
+        this.providers.set(name.toLowerCase(), provider);
+    }
+    get(name) {
+        return this.providers.get(name.toLowerCase());
+    }
+    getAll() {
+        return Array.from(this.providers.values());
+    }
+    has(name) {
+        return this.providers.has(name.toLowerCase());
+    }
+    list() {
+        return Array.from(this.providers.keys());
+    }
+    clear() {
+        this.providers.clear();
+    }
+}
+export class ProviderFactory {
+    registry = new ProviderRegistry();
+    createProvider(type, credentials) {
+        const lowerType = type.toLowerCase();
+        switch (lowerType) {
+            case 'gemini': {
+                return new GeminiProvider(credentials);
+            }
+            case 'copilot': {
+                return new CopilotProvider(credentials);
+            }
+            case 'kilo': {
+                return new KiloProvider(credentials);
+            }
+            case 'opencode': {
+                return new OpenCodeProvider(credentials);
+            }
+            default: {
+                throw new Error(`Unknown provider type: ${type}`);
+            }
+        }
+    }
+    registerProvider(name, provider) {
+        this.registry.register(name, provider);
+    }
+    getProvider(name) {
+        return this.registry.get(name);
+    }
+    getAllProviders() {
+        return this.registry.getAll();
+    }
+    hasProvider(name) {
+        return this.registry.has(name);
+    }
+    listProviders() {
+        return this.registry.list();
+    }
+    clearProviders() {
+        this.registry.clear();
+    }
+}
+// Export singleton instance
+export const providerFactory = new ProviderFactory();
+/**
+ * Get or create a provider by type with credentials
+ */
+export function getProvider(type, credentials) {
+    // If no credentials provided, create with empty credentials
+    const creds = credentials || { apiKey: '' };
+    return providerFactory.createProvider(type, creds);
+}
+/**
+ * Get list of supported provider types
+ */
+export function getSupportedProviders() {
+    return ['gemini', 'copilot', 'kilo', 'opencode'];
+}

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

@@ -0,0 +1,22 @@
+/**
+ * Kilo-gateway provider implementation
+ * Kilo is an LLM router with free and paid models
+ * API: https://kilo.ai/  — free models still require an API key from https://app.kilo.ai
+ */
+import { Provider } from './base.js';
+import type { EnhancementOptions, ProviderCredentials } from '../types/index.js';
+export declare const KILO_MODELS: {
+    id: string;
+    name: string;
+}[];
+export declare const KILO_DEFAULT_ENDPOINT = "https://api.kilo.ai/api/gateway/chat/completions";
+export declare const KILO_DEFAULT_MODEL = "minimax/minimax-m2.5";
+export declare class KiloProvider extends Provider {
+    private endpoint;
+    constructor(credentials: ProviderCredentials);
+    private buildHeaders;
+    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/kilo.js

@@ -0,0 +1,174 @@
+/**
+ * Kilo-gateway provider implementation
+ * Kilo is an LLM router with free and paid models
+ * API: https://kilo.ai/  — free models still require an API key from https://app.kilo.ai
+ */
+import { Provider } from './base.js';
+export const KILO_MODELS = [
+    {
+        id: 'openrouter/free',
+        name: 'OpenRouter Free Router (auto-select free model)',
+    },
+    { id: 'minimax/minimax-m2.5', name: 'MiniMax M2.5 (recommended)' },
+    { id: 'minimax/minimax-m2.1', name: 'MiniMax M2.1' },
+    { id: 'minimax/minimax', name: 'MiniMax' },
+    { id: 'arcee-ai/trinity-large', name: 'Arcee AI Trinity Large' },
+    { id: 'z-ai/glm-4-7-flash-preview', name: 'Z.ai GLM 4.7 Flash Preview (free)' },
+    { id: 'qwen/qwen3-coder-next', name: 'Qwen3 Coder Next' },
+    { id: 'qwen/qwen3-coder-480b-a35b', name: 'Qwen3 Coder 480B A35B' },
+    { id: 'xai/grok-code-fast-1', name: 'xAI Grok Code Fast 1' },
+    { id: 'kwaipilot/kat-coder-pro-v1', name: 'KwaiPilot KAT-Coder-Pro V1' },
+    { id: 'deepseek/deepseek-chat-v3.1', name: 'DeepSeek V3.1 Terminus' },
+];
+export const KILO_DEFAULT_ENDPOINT = 'https://api.kilo.ai/api/gateway/chat/completions';
+export const KILO_DEFAULT_MODEL = 'minimax/minimax-m2.5';
+const SYSTEM_PROMPT = '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.';
+async function throwOnError(response) {
+    let body = '';
+    try {
+        body = await response.text();
+    }
+    catch {
+        // ignore
+    }
+    if (body) {
+        try {
+            const parsed = JSON.parse(body);
+            const errorMsg = parsed.error?.message ?? parsed.message;
+            if (response.status === 429) {
+                throw new Error(`Kilo: Rate limited${errorMsg ? ` — ${errorMsg}` : ''}. Wait a moment or use a different model.`);
+            }
+            if (errorMsg) {
+                throw new Error(`Kilo error: ${errorMsg}`);
+            }
+        }
+        catch (e) {
+            if (!(e instanceof SyntaxError))
+                throw e;
+        }
+    }
+    throw new Error(`Kilo API error: ${response.status} ${response.statusText}${body ? ` — ${body}` : ''}`);
+}
+export class KiloProvider extends Provider {
+    endpoint;
+    constructor(credentials) {
+        super('kilo', credentials, KILO_DEFAULT_MODEL);
+        this.endpoint = credentials.endpoint || KILO_DEFAULT_ENDPOINT;
+    }
+    buildHeaders() {
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (this.credentials.apiKey) {
+            headers['Authorization'] = `Bearer ${this.credentials.apiKey}`;
+        }
+        return headers;
+    }
+    async enhance(prompt, options) {
+        const body = {
+            messages: [
+                { role: 'system', content: options?.systemPrompt || SYSTEM_PROMPT },
+                { role: 'user', content: `Original prompt:\n${prompt}` },
+            ],
+            model: options?.model || this.defaultModel,
+            temperature: options?.temperature ?? 0.7,
+            max_tokens: options?.maxTokens ?? 1000,
+            stream: false,
+        };
+        const response = await fetch(this.endpoint, {
+            method: 'POST',
+            headers: this.buildHeaders(),
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            await throwOnError(response);
+        }
+        const data = (await response.json());
+        const content = data.choices[0]?.message?.content;
+        if (!content)
+            throw new Error('No response received from Kilo');
+        return content.trim();
+    }
+    async *enhanceStream(prompt, options) {
+        const body = {
+            messages: [
+                { role: 'system', content: options?.systemPrompt || SYSTEM_PROMPT },
+                { role: 'user', content: `Original prompt:\n${prompt}` },
+            ],
+            model: options?.model || this.defaultModel,
+            temperature: options?.temperature ?? 0.7,
+            max_tokens: options?.maxTokens ?? 1000,
+            stream: true,
+        };
+        const response = await fetch(this.endpoint, {
+            method: 'POST',
+            headers: this.buildHeaders(),
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            await throwOnError(response);
+        }
+        if (!response.body)
+            throw new Error('No response stream from Kilo');
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                for (let i = 0; i < lines.length - 1; i++) {
+                    const line = lines[i];
+                    if (line.startsWith('data: ')) {
+                        const data = line.slice(6).trim();
+                        if (data === '[DONE]')
+                            return;
+                        try {
+                            const parsed = JSON.parse(data);
+                            if (parsed.error) {
+                                const msg = parsed.error.message ?? JSON.stringify(parsed.error);
+                                throw new Error(`Kilo stream error: ${msg}`);
+                            }
+                            const content = parsed.choices?.[0]?.delta?.content;
+                            if (content)
+                                yield content;
+                        }
+                        catch (e) {
+                            if (e instanceof SyntaxError)
+                                continue;
+                            throw e;
+                        }
+                    }
+                }
+                buffer = lines[lines.length - 1];
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    async getAvailableModels() {
+        return KILO_MODELS.map(m => m.id);
+    }
+    async validateCredentials() {
+        try {
+            const response = await fetch(this.endpoint, {
+                method: 'POST',
+                headers: this.buildHeaders(),
+                body: JSON.stringify({
+                    messages: [{ role: 'user', content: 'test' }],
+                    model: KILO_DEFAULT_MODEL,
+                    max_tokens: 1,
+                    stream: false,
+                }),
+            });
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+}

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

@@ -0,0 +1,22 @@
+/**
+ * OpenCode provider implementation
+ * OpenCode is an AI gateway with an OpenAI-compatible API
+ * Models endpoint: https://opencode.ai/zen/v1/models
+ * Chat completions: https://opencode.ai/zen/v1/chat/completions
+ */
+import { Provider } from './base.js';
+import type { EnhancementOptions, ProviderCredentials } from '../types/index.js';
+export declare const OPENCODE_BASE_URL = "https://opencode.ai/zen/v1";
+export declare const OPENCODE_MODELS_ENDPOINT = "https://opencode.ai/zen/v1/models";
+export declare const OPENCODE_CHAT_ENDPOINT = "https://opencode.ai/zen/v1/chat/completions";
+export declare const OPENCODE_DEFAULT_MODEL = "anthropic/claude-sonnet-4-5";
+export declare class OpenCodeProvider extends Provider {
+    private chatEndpoint;
+    private modelsEndpoint;
+    constructor(credentials: ProviderCredentials);
+    private buildHeaders;
+    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/opencode.js

@@ -0,0 +1,174 @@
+/**
+ * OpenCode provider implementation
+ * OpenCode is an AI gateway with an OpenAI-compatible API
+ * Models endpoint: https://opencode.ai/zen/v1/models
+ * Chat completions: https://opencode.ai/zen/v1/chat/completions
+ */
+import { Provider } from './base.js';
+export const OPENCODE_BASE_URL = 'https://opencode.ai/zen/v1';
+export const OPENCODE_MODELS_ENDPOINT = `${OPENCODE_BASE_URL}/models`;
+export const OPENCODE_CHAT_ENDPOINT = `${OPENCODE_BASE_URL}/chat/completions`;
+export const OPENCODE_DEFAULT_MODEL = 'anthropic/claude-sonnet-4-5';
+const SYSTEM_PROMPT = '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.';
+async function throwOnError(response, provider = 'OpenCode') {
+    let body = '';
+    try {
+        body = await response.text();
+    }
+    catch {
+        // ignore
+    }
+    if (body) {
+        try {
+            const parsed = JSON.parse(body);
+            const errorType = parsed.error?.type;
+            const errorMsg = parsed.error?.message ?? parsed.message;
+            if (errorType === 'FreeUsageLimitError') {
+                throw new Error(`${provider}: Free usage limit reached. Switch to a paid model or try a different provider.`);
+            }
+            if (response.status === 429) {
+                throw new Error(`${provider}: Rate limited${errorMsg ? ` — ${errorMsg}` : ''}. Wait a moment or use a different model.`);
+            }
+            if (errorMsg) {
+                throw new Error(`${provider} error: ${errorMsg}`);
+            }
+        }
+        catch (e) {
+            if (!(e instanceof SyntaxError))
+                throw e;
+        }
+    }
+    throw new Error(`${provider} API error: ${response.status} ${response.statusText}${body ? ` — ${body}` : ''}`);
+}
+export class OpenCodeProvider extends Provider {
+    chatEndpoint;
+    modelsEndpoint;
+    constructor(credentials) {
+        super('opencode', credentials, OPENCODE_DEFAULT_MODEL);
+        const base = credentials.endpoint
+            ? credentials.endpoint.replace(/\/chat\/completions$/, '')
+            : OPENCODE_BASE_URL;
+        this.chatEndpoint = `${base}/chat/completions`;
+        this.modelsEndpoint = `${base}/models`;
+    }
+    buildHeaders() {
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (this.credentials.apiKey) {
+            headers['Authorization'] = `Bearer ${this.credentials.apiKey}`;
+        }
+        return headers;
+    }
+    async enhance(prompt, options) {
+        const body = {
+            messages: [
+                { role: 'system', content: options?.systemPrompt || SYSTEM_PROMPT },
+                { role: 'user', content: `Original prompt:\n${prompt}` },
+            ],
+            model: options?.model || this.defaultModel,
+            temperature: options?.temperature ?? 0.7,
+            max_tokens: options?.maxTokens ?? 1000,
+            stream: false,
+        };
+        const response = await fetch(this.chatEndpoint, {
+            method: 'POST',
+            headers: this.buildHeaders(),
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            await throwOnError(response);
+        }
+        const data = (await response.json());
+        const content = data.choices[0]?.message?.content;
+        if (!content)
+            throw new Error('No response received from OpenCode');
+        return content.trim();
+    }
+    async *enhanceStream(prompt, options) {
+        const body = {
+            messages: [
+                { role: 'system', content: options?.systemPrompt || SYSTEM_PROMPT },
+                { role: 'user', content: `Original prompt:\n${prompt}` },
+            ],
+            model: options?.model || this.defaultModel,
+            temperature: options?.temperature ?? 0.7,
+            max_tokens: options?.maxTokens ?? 1000,
+            stream: true,
+        };
+        const response = await fetch(this.chatEndpoint, {
+            method: 'POST',
+            headers: this.buildHeaders(),
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            await throwOnError(response);
+        }
+        if (!response.body)
+            throw new Error('No response stream from OpenCode');
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                for (let i = 0; i < lines.length - 1; i++) {
+                    const line = lines[i];
+                    if (line.startsWith('data: ')) {
+                        const data = line.slice(6).trim();
+                        if (data === '[DONE]')
+                            return;
+                        try {
+                            const parsed = JSON.parse(data);
+                            if (parsed.error) {
+                                const msg = parsed.error.message ?? JSON.stringify(parsed.error);
+                                const type = parsed.error.type;
+                                if (type === 'FreeUsageLimitError') {
+                                    throw new Error('OpenCode: Free usage limit reached. Switch to a paid model or try a different provider.');
+                                }
+                                throw new Error(`OpenCode stream error: ${msg}`);
+                            }
+                            const content = parsed.choices?.[0]?.delta?.content;
+                            if (content)
+                                yield content;
+                        }
+                        catch (e) {
+                            if (e instanceof SyntaxError)
+                                continue;
+                            throw e;
+                        }
+                    }
+                }
+                buffer = lines[lines.length - 1];
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    async getAvailableModels() {
+        const response = await fetch(this.modelsEndpoint, {
+            headers: this.buildHeaders(),
+        });
+        if (!response.ok) {
+            await throwOnError(response);
+        }
+        const data = (await response.json());
+        return data.data.map(m => m.id).filter(Boolean);
+    }
+    async validateCredentials() {
+        try {
+            const response = await fetch(this.modelsEndpoint, {
+                headers: this.buildHeaders(),
+            });
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+}

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

@@ -0,0 +1,26 @@
+/**
+ * Shared types for prompt-enhancer
+ */
+export interface EnhancementOptions {
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    systemPrompt?: string;
+}
+export interface EnhancementResult {
+    enhanced: string;
+    model: string;
+    provider: string;
+    tokensUsed?: number;
+    duration?: number;
+}
+export interface StreamChunk {
+    content: string;
+    done: boolean;
+}
+export interface ProviderCredentials {
+    apiKey: string;
+    endpoint?: string;
+    project?: string;
+    useOAuth?: boolean;
+}

package/dist/lib/types/index.js

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

package/dist/lib/utils/copilot-auth.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Auto-detects Copilot / GitHub OAuth credentials from well-known filesystem paths.
+ *
+ * Checked in order:
+ *  1. ~/.copilot/hosts.json       (Copilot CLI)
+ *  2. ~/.config/github-copilot/hosts.json  (Linux/Mac VSCode extension)
+ *  3. %APPDATA%\GitHub Copilot\hosts.json  (Windows VSCode extension)
+ *  4. ~/.config/gh/hosts.yml      (GitHub CLI — requires `js-yaml` or manual parse)
+ */
+/**
+ * Attempts to auto-detect a GitHub/Copilot OAuth token from the local machine.
+ * Returns `null` if no token can be found.
+ */
+export declare function getCopilotToken(): Promise<string | null>;

package/dist/lib/utils/copilot-auth.js

@@ -0,0 +1,84 @@
+/**
+ * Auto-detects Copilot / GitHub OAuth credentials from well-known filesystem paths.
+ *
+ * Checked in order:
+ *  1. ~/.copilot/hosts.json       (Copilot CLI)
+ *  2. ~/.config/github-copilot/hosts.json  (Linux/Mac VSCode extension)
+ *  3. %APPDATA%\GitHub Copilot\hosts.json  (Windows VSCode extension)
+ *  4. ~/.config/gh/hosts.yml      (GitHub CLI — requires `js-yaml` or manual parse)
+ */
+import { readFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+async function readJsonToken(filePath) {
+    try {
+        const raw = await readFile(filePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        const ghEntry = parsed['github.com'] ?? parsed['api.github.com'];
+        const token = ghEntry?.oauth_token ?? ghEntry?.token ?? null;
+        return typeof token === 'string' && token.length > 0 ? token : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Minimal YAML-line parser — only handles `oauth_token: <value>` under a `github.com:` block. */
+async function readYamlToken(filePath) {
+    try {
+        const raw = await readFile(filePath, 'utf-8');
+        let inGithubBlock = false;
+        for (const line of raw.split('\n')) {
+            if (/^github\.com:/.test(line)) {
+                inGithubBlock = true;
+                continue;
+            }
+            if (inGithubBlock) {
+                // Exit block on a new top-level key
+                if (/^\S/.test(line) &&
+                    !line.startsWith(' ') &&
+                    !line.startsWith('\t')) {
+                    break;
+                }
+                const match = /oauth_token:\s*(.+)/.exec(line);
+                if (match) {
+                    return match[1].trim();
+                }
+            }
+        }
+    }
+    catch {
+        // Ignore
+    }
+    return null;
+}
+/**
+ * Attempts to auto-detect a GitHub/Copilot OAuth token from the local machine.
+ * Returns `null` if no token can be found.
+ */
+export async function getCopilotToken() {
+    const home = homedir();
+    const jsonPaths = [
+        join(home, '.copilot', 'hosts.json'),
+        join(home, '.config', 'github-copilot', 'hosts.json'),
+    ];
+    // Windows: %APPDATA%\GitHub Copilot\hosts.json
+    if (process.env['APPDATA']) {
+        jsonPaths.push(join(process.env['APPDATA'], 'GitHub Copilot', 'hosts.json'));
+    }
+    for (const p of jsonPaths) {
+        if (existsSync(p)) {
+            const token = await readJsonToken(p);
+            if (token)
+                return token;
+        }
+    }
+    // GitHub CLI fallback: ~/.config/gh/hosts.yml
+    const yamlPath = join(home, '.config', 'gh', 'hosts.yml');
+    if (existsSync(yamlPath)) {
+        const token = await readYamlToken(yamlPath);
+        if (token)
+            return token;
+    }
+    return null;
+}

package/dist/lib/utils/models-cache.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Fetches and caches the models list from https://models.dev/api.json
+ * Cache TTL is 24 hours, stored at ~/.prompt-enhancer/models-cache.json
+ */
+export interface ModelEntry {
+    id: string;
+    name: string;
+}
+/**
+ * Falls back to a hardcoded list if network is unavailable.
+ */
+export declare function getModelsForProvider(provider: 'gemini' | 'copilot' | 'kilo' | 'opencode', apiKey?: string): Promise<ModelEntry[]>;