english-optimizer-cli 1.0.0

package/dist/ai/ollama.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OllamaProvider = void 0;
+const axios_1 = __importDefault(require("axios"));
+const templates_1 = require("../prompts/templates");
+class OllamaProvider {
+    constructor(config) {
+        this.config = config;
+    }
+    async optimize(text, mode) {
+        const prompt = (0, templates_1.getPromptTemplate)(mode, text);
+        try {
+            const response = await axios_1.default.post(`${this.config.baseUrl}/api/generate`, {
+                model: this.config.model,
+                prompt: prompt,
+                stream: false,
+                options: {
+                    temperature: 0.7,
+                    top_p: 0.9,
+                },
+            }, {
+                timeout: 60000, // 60 seconds timeout
+            });
+            if (response.data && response.data.response) {
+                // Extract the optimized text from the response
+                let result = response.data.response.trim();
+                // Remove quotes if the model wrapped the response in them
+                if (result.startsWith('"') && result.endsWith('"')) {
+                    result = result.slice(1, -1);
+                }
+                // Remove common prefixes if present
+                const prefixesToRemove = ['Rewritten text:', 'Corrected text:', 'Optimized text:'];
+                for (const prefix of prefixesToRemove) {
+                    if (result.startsWith(prefix)) {
+                        result = result.slice(prefix.length).trim();
+                    }
+                }
+                return result;
+            }
+            throw new Error('Invalid response from Ollama');
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error)) {
+                const axiosError = error;
+                if (axiosError.code === 'ECONNREFUSED') {
+                    throw new Error(`Cannot connect to Ollama at ${this.config.baseUrl}. Make sure Ollama is running.`);
+                }
+                throw new Error(`Ollama API error: ${axiosError.message}`);
+            }
+            throw error;
+        }
+    }
+    async generateWithPrompt(prompt) {
+        try {
+            const response = await axios_1.default.post(`${this.config.baseUrl}/api/generate`, {
+                model: this.config.model,
+                prompt: prompt,
+                stream: false,
+                options: {
+                    temperature: 0.7,
+                    top_p: 0.9,
+                },
+            }, {
+                timeout: 60000,
+            });
+            if (response.data && response.data.response) {
+                let result = response.data.response.trim();
+                // Remove quotes if the model wrapped the response in them
+                if (result.startsWith('"') && result.endsWith('"')) {
+                    result = result.slice(1, -1);
+                }
+                return result;
+            }
+            throw new Error('Invalid response from Ollama');
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error)) {
+                const axiosError = error;
+                if (axiosError.code === 'ECONNREFUSED') {
+                    throw new Error(`Cannot connect to Ollama at ${this.config.baseUrl}. Make sure Ollama is running.`);
+                }
+                throw new Error(`Ollama API error: ${axiosError.message}`);
+            }
+            throw error;
+        }
+    }
+    async isAvailable() {
+        try {
+            const response = await axios_1.default.get(`${this.config.baseUrl}/api/tags`, {
+                timeout: 5000,
+            });
+            return response.status === 200;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.OllamaProvider = OllamaProvider;
+//# sourceMappingURL=ollama.js.map

package/dist/ai/provider.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiProvider = exports.OllamaProvider = void 0;
+exports.createProvider = createProvider;
+const ollama_1 = require("./ollama");
+const api_provider_1 = require("./api-provider");
+function createProvider(config) {
+    if (config.ai.provider === 'ollama') {
+        if (!config.ai.ollama) {
+            throw new Error('Ollama configuration is missing');
+        }
+        return new ollama_1.OllamaProvider(config.ai.ollama);
+    }
+    else if (config.ai.provider === 'api') {
+        if (!config.ai.api) {
+            throw new Error('API configuration is missing');
+        }
+        return new api_provider_1.ApiProvider(config.ai.api);
+    }
+    throw new Error(`Unknown provider: ${config.ai.provider}`);
+}
+var ollama_2 = require("./ollama");
+Object.defineProperty(exports, "OllamaProvider", { enumerable: true, get: function () { return ollama_2.OllamaProvider; } });
+var api_provider_2 = require("./api-provider");
+Object.defineProperty(exports, "ApiProvider", { enumerable: true, get: function () { return api_provider_2.ApiProvider; } });
+//# sourceMappingURL=provider.js.map

package/dist/config/config.js

@@ -0,0 +1,223 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configManager = exports.ConfigManager = void 0;
+const zod_1 = require("zod");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const dotenv_1 = __importDefault(require("dotenv"));
+const yaml = __importStar(require("js-yaml"));
+// Load environment variables
+dotenv_1.default.config();
+// Zod schema for validation
+const ConfigSchema = zod_1.z.object({
+    ai: zod_1.z.object({
+        provider: zod_1.z.enum(['ollama', 'api']),
+        ollama: zod_1.z
+            .object({
+            baseUrl: zod_1.z.string().url(),
+            model: zod_1.z.string(),
+        })
+            .optional(),
+        api: zod_1.z
+            .object({
+            provider: zod_1.z.enum(['openai', 'glm', 'custom']),
+            apiKey: zod_1.z.string(),
+            baseUrl: zod_1.z.string().url(),
+            model: zod_1.z.string(),
+        })
+            .optional(),
+    }),
+    hotkeys: zod_1.z.record(zod_1.z.string()),
+    features: zod_1.z.object({
+        enableHistory: zod_1.z.boolean(),
+        historyPath: zod_1.z.string(),
+        enableCustomPrompts: zod_1.z.boolean(),
+        customPromptsPath: zod_1.z.string(),
+    }),
+});
+const DEFAULT_CONFIG = {
+    ai: {
+        provider: 'ollama',
+        ollama: {
+            baseUrl: 'http://localhost:11434',
+            model: 'llama3.2:3b',
+        },
+        api: {
+            provider: 'openai',
+            apiKey: '',
+            baseUrl: 'https://api.openai.com/v1',
+            model: 'gpt-3.5-turbo',
+        },
+    },
+    hotkeys: {
+        professional: 'p',
+        concise: 'c',
+        grammar: 'g',
+        senior_developer: 'd',
+        reset: 'r',
+        history: 'h',
+        quit: 'q',
+    },
+    features: {
+        enableHistory: true,
+        historyPath: (0, path_1.join)((0, os_1.homedir)(), '.english-optimizer', 'history.json'),
+        enableCustomPrompts: true,
+        customPromptsPath: (0, path_1.join)((0, os_1.homedir)(), '.english-optimizer', 'prompts.json'),
+    },
+};
+const CONFIG_DIR = (0, path_1.join)((0, os_1.homedir)(), '.english-optimizer');
+const CONFIG_FILE_YAML = (0, path_1.join)(CONFIG_DIR, 'config.yaml');
+const CONFIG_FILE_JSON = (0, path_1.join)(CONFIG_DIR, 'config.json');
+class ConfigManager {
+    constructor() {
+        this.config = this.loadConfig();
+    }
+    loadConfig() {
+        // Try to load from YAML config file first, then JSON
+        let configFilePath = null;
+        let fileContent = '';
+        if ((0, fs_1.existsSync)(CONFIG_FILE_YAML)) {
+            configFilePath = CONFIG_FILE_YAML;
+            try {
+                fileContent = (0, fs_1.readFileSync)(CONFIG_FILE_YAML, 'utf-8');
+                const fileConfig = yaml.load(fileContent);
+                const mergedConfig = this.mergeWithDefaults(fileConfig);
+                const validated = ConfigSchema.parse(mergedConfig);
+                return validated;
+            }
+            catch (error) {
+                console.warn('Failed to load YAML config file, trying JSON:', error);
+            }
+        }
+        if ((0, fs_1.existsSync)(CONFIG_FILE_JSON)) {
+            configFilePath = CONFIG_FILE_JSON;
+            try {
+                fileContent = (0, fs_1.readFileSync)(CONFIG_FILE_JSON, 'utf-8');
+                const fileConfig = JSON.parse(fileContent);
+                const mergedConfig = this.mergeWithDefaults(fileConfig);
+                const validated = ConfigSchema.parse(mergedConfig);
+                return validated;
+            }
+            catch (error) {
+                console.warn('Failed to load JSON config file, using defaults:', error);
+            }
+        }
+        // Load from environment variables
+        const envConfig = this.loadFromEnv();
+        const mergedConfig = this.mergeWithDefaults(envConfig);
+        return ConfigSchema.parse(mergedConfig);
+    }
+    loadFromEnv() {
+        const env = {};
+        if (process.env.AI_PROVIDER) {
+            env.ai = {
+                provider: process.env.AI_PROVIDER,
+            };
+            if (process.env.AI_PROVIDER === 'ollama') {
+                env.ai.ollama = {
+                    baseUrl: process.env.OLLAMA_BASE_URL || 'http://localhost:11434',
+                    model: process.env.OLLAMA_MODEL || 'llama3.2:3b',
+                };
+            }
+            else if (process.env.AI_PROVIDER === 'api') {
+                env.ai.api = {
+                    provider: process.env.API_PROVIDER || 'openai',
+                    apiKey: process.env.API_KEY || '',
+                    baseUrl: process.env.API_BASE_URL || 'https://api.openai.com/v1',
+                    model: process.env.API_MODEL || 'gpt-3.5-turbo',
+                };
+            }
+        }
+        if (process.env.ENABLE_HISTORY !== undefined) {
+            env.features = {
+                enableHistory: process.env.ENABLE_HISTORY === 'true',
+                enableCustomPrompts: process.env.ENABLE_CUSTOM_PROMPTS !== undefined
+                    ? process.env.ENABLE_CUSTOM_PROMPTS === 'true'
+                    : true,
+                historyPath: (0, path_1.join)((0, os_1.homedir)(), '.english-optimizer', 'history.json'),
+                customPromptsPath: (0, path_1.join)((0, os_1.homedir)(), '.english-optimizer', 'prompts.json'),
+            };
+        }
+        return env;
+    }
+    mergeWithDefaults(partial) {
+        return {
+            ai: {
+                ...DEFAULT_CONFIG.ai,
+                ...partial.ai,
+                ollama: partial.ai?.ollama
+                    ? { ...DEFAULT_CONFIG.ai.ollama, ...partial.ai.ollama }
+                    : DEFAULT_CONFIG.ai.ollama,
+                api: partial.ai?.api
+                    ? { ...DEFAULT_CONFIG.ai.api, ...partial.ai.api }
+                    : DEFAULT_CONFIG.ai.api,
+            },
+            hotkeys: { ...DEFAULT_CONFIG.hotkeys, ...partial.hotkeys },
+            features: { ...DEFAULT_CONFIG.features, ...partial.features },
+        };
+    }
+    getConfig() {
+        return this.config;
+    }
+    saveConfig(config) {
+        const validated = ConfigSchema.parse(config);
+        // Ensure config directory exists
+        if (!(0, fs_1.existsSync)(CONFIG_DIR)) {
+            (0, fs_1.mkdirSync)(CONFIG_DIR, { recursive: true });
+        }
+        // Save to YAML if it exists or by default, otherwise use JSON
+        const configFilePath = (0, fs_1.existsSync)(CONFIG_FILE_YAML) ? CONFIG_FILE_YAML : CONFIG_FILE_JSON;
+        if (configFilePath.endsWith('.yaml')) {
+            (0, fs_1.writeFileSync)(configFilePath, yaml.dump(validated, { indent: 2 }), 'utf-8');
+        }
+        else {
+            (0, fs_1.writeFileSync)(configFilePath, JSON.stringify(validated, null, 2), 'utf-8');
+        }
+        this.config = validated;
+    }
+    static ensureConfigDir() {
+        if (!(0, fs_1.existsSync)(CONFIG_DIR)) {
+            (0, fs_1.mkdirSync)(CONFIG_DIR, { recursive: true });
+        }
+    }
+}
+exports.ConfigManager = ConfigManager;
+exports.configManager = new ConfigManager();
+//# sourceMappingURL=config.js.map

package/dist/core/batch.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchProcessor = void 0;
+const fs_1 = require("fs");
+const display_1 = require("../utils/display");
+class BatchProcessor {
+    constructor(optimizer) {
+        this.optimizer = optimizer;
+    }
+    async processBatch(options) {
+        (0, display_1.displayInfo)(`Processing ${options.files.length} file(s)...`);
+        for (const file of options.files) {
+            await this.processFile(file, options);
+        }
+        (0, display_1.displayInfo)(`Batch processing complete!`);
+    }
+    async processFile(filePath, options) {
+        try {
+            // Read file
+            const content = (0, fs_1.readFileSync)(filePath, 'utf-8');
+            (0, display_1.displayModeInfo)(options.mode);
+            console.log(`\nProcessing: ${filePath}`);
+            // Optimize content
+            const result = await this.optimizer.optimize(content, options.mode);
+            (0, display_1.displayOptimization)(result.original, result.optimized);
+            // Write output
+            if (options.inPlace) {
+                (0, fs_1.writeFileSync)(filePath, result.optimized, 'utf-8');
+                console.log(`✅ Updated: ${filePath}`);
+            }
+            else {
+                const outputPath = options.outputSuffix
+                    ? filePath.replace(/(\.[^.]+)$/, `${options.outputSuffix}$1`)
+                    : `${filePath}.optimized`;
+                (0, fs_1.writeFileSync)(outputPath, result.optimized, 'utf-8');
+                console.log(`✅ Created: ${outputPath}`);
+            }
+        }
+        catch (error) {
+            console.error(`❌ Error processing ${filePath}:`, error);
+        }
+    }
+}
+exports.BatchProcessor = BatchProcessor;
+//# sourceMappingURL=batch.js.map

package/dist/core/editor.js

@@ -0,0 +1,175 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InteractiveEditor = void 0;
+const readline_1 = __importDefault(require("readline"));
+const process_1 = require("process");
+const chalk_1 = __importDefault(require("chalk"));
+const types_1 = require("../types");
+const display_1 = require("../utils/display");
+const config_1 = require("../config/config");
+class InteractiveEditor {
+    constructor(optimizer, historyLogger, customPromptLoader) {
+        this.currentText = '';
+        this.optimizer = optimizer;
+        this.historyLogger = historyLogger;
+        this.customPromptLoader = customPromptLoader;
+        this.rl = readline_1.default.createInterface({
+            input: process_1.stdin,
+            output: process_1.stdout,
+        });
+    }
+    async start() {
+        (0, display_1.displayWelcome)();
+        (0, display_1.displayHelp)();
+        console.log('\nEnter your text (press Enter twice to finish):\n');
+        // Read multi-line input
+        const lines = [];
+        let emptyLineCount = 0;
+        while (true) {
+            const line = await this.question('');
+            lines.push(line);
+            if (line.trim() === '') {
+                emptyLineCount++;
+                if (emptyLineCount >= 1) {
+                    break;
+                }
+            }
+            else {
+                emptyLineCount = 0;
+            }
+        }
+        this.currentText = lines.join('\n').trim();
+        if (!this.currentText) {
+            (0, display_1.displayInfo)('No text provided. Exiting...');
+            this.rl.close();
+            return;
+        }
+        await this.runOptimizationLoop();
+    }
+    async runOptimizationLoop() {
+        const config = config_1.configManager.getConfig();
+        while (true) {
+            console.log('\n' + '═'.repeat(60));
+            console.log(chalk_1.default.cyan('Current text:'));
+            console.log(chalk_1.default.gray(this.currentText));
+            console.log('═'.repeat(60));
+            console.log(chalk_1.default.yellow('\nPress a hotkey (or Ctrl+Q to quit):'));
+            // Use raw mode to capture single keypress
+            const key = await this.captureKeypress();
+            if (key === '\u0003' || key === 'q') {
+                // Ctrl+C or q
+                console.log('\n\nGoodbye! 👋\n');
+                break;
+            }
+            else if (key === 'r') {
+                // Reset
+                console.log(chalk_1.default.yellow('\n↺ Reset to original'));
+                continue;
+            }
+            else if (key === 'h') {
+                // History
+                await this.showHistory();
+                continue;
+            }
+            else if (key === 'p') {
+                // Professional
+                await this.performOptimization(types_1.OptimizationMode.PROFESSIONAL);
+            }
+            else if (key === 'c') {
+                // Concise
+                await this.performOptimization(types_1.OptimizationMode.CONCISE);
+            }
+            else if (key === 'g') {
+                // Grammar
+                await this.performOptimization(types_1.OptimizationMode.GRAMMAR);
+            }
+            else if (key === 'd') {
+                // Senior Developer
+                await this.performOptimization(types_1.OptimizationMode.SENIOR_DEVELOPER);
+            }
+            else if (this.customPromptLoader && config.features.enableCustomPrompts) {
+                // Check for custom prompt hotkeys
+                const customPrompt = this.customPromptLoader.getPromptByHotkey(key);
+                if (customPrompt) {
+                    await this.performCustomOptimization(customPrompt);
+                    continue;
+                }
+            }
+        }
+        this.rl.close();
+    }
+    async performOptimization(mode) {
+        try {
+            (0, display_1.displayModeInfo)(mode);
+            console.log(chalk_1.default.gray('Optimizing...'));
+            const result = await this.optimizer.optimize(this.currentText, mode);
+            (0, display_1.displayOptimization)(result.original, result.optimized);
+            // Ask if user wants to use the optimized version
+            const accept = await this.question('\nUse this version? (y/n): ');
+            if (accept.toLowerCase() === 'y') {
+                this.currentText = result.optimized;
+                (0, display_1.displaySuccess)('Text updated!');
+            }
+        }
+        catch (error) {
+            (0, display_1.displayError)(error);
+        }
+    }
+    async performCustomOptimization(customPrompt) {
+        try {
+            console.log(chalk_1.default.yellow(`\n[${customPrompt.name}]`));
+            console.log(chalk_1.default.gray(customPrompt.description));
+            console.log(chalk_1.default.gray('Optimizing...'));
+            // For custom prompts, we'd need to extend the provider
+            // For now, this is a placeholder
+            (0, display_1.displayInfo)('Custom prompts will be implemented soon!');
+        }
+        catch (error) {
+            (0, display_1.displayError)(error);
+        }
+    }
+    async showHistory() {
+        if (!this.historyLogger) {
+            (0, display_1.displayInfo)('History is disabled.');
+            return;
+        }
+        const history = this.historyLogger.getRecentEntries(5);
+        if (history.length === 0) {
+            (0, display_1.displayInfo)('No history yet.');
+            return;
+        }
+        console.log(chalk_1.default.cyan('\n📜 Recent Optimizations:\n'));
+        for (const entry of history) {
+            (0, display_1.displayHistoryEntry)(entry);
+        }
+    }
+    question(query) {
+        return new Promise((resolve) => {
+            this.rl.question(query, (answer) => {
+                resolve(answer);
+            });
+        });
+    }
+    captureKeypress() {
+        return new Promise((resolve) => {
+            const originalRawMode = process_1.stdin.isRaw;
+            process_1.stdin.setRawMode(true);
+            process_1.stdin.resume();
+            process_1.stdin.once('data', (key) => {
+                process_1.stdin.setRawMode(originalRawMode);
+                process_1.stdin.pause();
+                process_1.stdin.removeAllListeners('data');
+                const str = key.toString('utf8');
+                resolve(str);
+            });
+        });
+    }
+    close() {
+        this.rl.close();
+    }
+}
+exports.InteractiveEditor = InteractiveEditor;
+//# sourceMappingURL=editor.js.map