cloving 0.3.20 → 1.0.1

package/dist/managers/ShellManager.js

@@ -1,163 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const cli_highlight_1 = __importDefault(require("cli-highlight"));
-const copy_paste_1 = __importDefault(require("copy-paste"));
-const child_process_1 = require("child_process");
-const prompts_1 = require("@inquirer/prompts");
-const cloving_gpt_1 = __importDefault(require("../cloving_gpt"));
-const prompt_utils_1 = require("../utils/prompt_utils");
-const string_utils_1 = require("../utils/string_utils");
-const config_utils_1 = require("../utils/config_utils");
-/**
- * ShellManager class for handling shell script generation and execution.
- */
-class ShellManager {
-    /**
-     * Creates an instance of ShellManager.
-     * @param {ClovingGPTOptions} options - The options for ClovingGPT.
-     */
-    constructor(options) {
-        this.options = options;
-        this.chatHistory = [];
-        options.silent = (0, config_utils_1.getConfig)(options).globalSilent || false;
-        this.gpt = new cloving_gpt_1.default(options);
-    }
-    /**
-     * Generates a prompt to explain a shell script.
-     * @param {string} prompt - The original shell script prompt.
-     * @returns {string} The prompt for explaining the shell script.
-     * @private
-     */
-    generateExplainShellPrompt(prompt) {
-        return `${prompt}
-
-# Task
-
-Please briefly explain how this shell script works.`;
-    }
-    /**
-     * Generates a shell script based on the given prompt.
-     * @param {string} prompt - The user's prompt for generating a shell script.
-     * @returns {Promise<string>} A promise that resolves to the generated shell script.
-     * @private
-     */
-    async generateShell(prompt) {
-        if (this.chatHistory.length === 0) {
-            const systemPrompt = (0, prompt_utils_1.generateShellPrompt)();
-            this.chatHistory.push({ role: 'user', content: systemPrompt });
-            this.chatHistory.push({ role: 'assistant', content: 'What would you like to do?' });
-        }
-        this.chatHistory.push({ role: 'user', content: prompt });
-        return await this.gpt.generateText({ prompt, messages: this.chatHistory });
-    }
-    /**
-     * Displays the generated shell script with syntax highlighting.
-     * @param {string} rawShellCommand - The raw shell command to display.
-     * @private
-     */
-    displayGeneratedShell(rawShellCommand) {
-        const generatedShell = (0, string_utils_1.extractMarkdown)(rawShellCommand);
-        const generatedShellWithoutShebang = generatedShell.replace(/^#!.*?\s/, '');
-        console.log((0, cli_highlight_1.default)(generatedShellWithoutShebang));
-    }
-    /**
-     * Handles user actions after generating a shell script.
-     * @param {string} response - The generated shell script.
-     * @param {string} prompt - The original user prompt.
-     * @returns {Promise<void>}
-     * @private
-     */
-    async handleUserAction(response, prompt) {
-        let { exec } = this.options;
-        this.chatHistory.push({ role: 'assistant', content: response });
-        const generatedShell = (0, string_utils_1.extractMarkdown)(response);
-        const generatedShellWithoutShebang = generatedShell.replace(/^#!.*?\s/, '');
-        if (exec) {
-            (0, child_process_1.execSync)(generatedShellWithoutShebang, { stdio: 'inherit' });
-            return;
-        }
-        const action = await (0, prompts_1.select)({
-            message: 'What would you like to do?',
-            choices: [
-                { name: 'Execute', value: 'execute' },
-                { name: 'Revise', value: 'revise' },
-                { name: 'Explain', value: 'explain' },
-                { name: 'Copy to Clipboard', value: 'copy' },
-                { name: 'Cancel', value: 'cancel' },
-            ],
-        });
-        switch (action) {
-            case 'execute':
-                (0, child_process_1.execSync)(generatedShellWithoutShebang, { stdio: 'inherit' });
-                break;
-            case 'revise':
-                const newPrompt = await (0, prompts_1.input)({
-                    message: 'How would you like to modify the output:',
-                });
-                const newRawShellCommand = await this.generateShell(newPrompt);
-                this.displayGeneratedShell(newRawShellCommand);
-                await this.handleUserAction(newRawShellCommand, newPrompt);
-                break;
-            case 'explain':
-                const explainPrompt = this.generateExplainShellPrompt(generatedShellWithoutShebang);
-                this.chatHistory.push({ role: 'user', content: explainPrompt });
-                const explainShellCommand = await this.gpt.generateText({
-                    prompt: explainPrompt,
-                    messages: this.chatHistory,
-                });
-                console.log((0, cli_highlight_1.default)(explainShellCommand, { language: 'markdown' }));
-                break;
-            case 'copy':
-                copy_paste_1.default.copy(generatedShellWithoutShebang, (err) => {
-                    if (err) {
-                        console.error('Error: Unable to copy to clipboard.', err);
-                    }
-                    else {
-                        console.log('Script copied to clipboard.');
-                    }
-                });
-                break;
-            case 'cancel':
-                console.log('Operation cancelled.');
-                break;
-        }
-    }
-    /**
-     * Generates a shell script based on user input and handles subsequent user actions.
-     *
-     * This method is the main entry point for generating and interacting with shell scripts.
-     * It performs the following steps:
-     * 1. Obtains a user prompt (either from options or by asking the user).
-     * 2. Generates a shell script based on the prompt.
-     * 3. Displays the generated script with syntax highlighting.
-     * 4. Handles user actions (execute, revise, explain, copy, or cancel) for the generated script.
-     *
-     * @returns {Promise<void>} A promise that resolves when the generation and handling process is complete.
-     * @throws {Error} If there's an issue during the shell script generation process.
-     * @public
-     *
-     * @example
-     * const shellManager = new ShellManager(options);
-     * await shellManager.generateAndHandleShell();
-     */
-    async generateAndHandleShell() {
-        let { prompt: userPrompt } = this.options;
-        try {
-            if (!userPrompt) {
-                userPrompt = await (0, prompts_1.input)({
-                    message: 'What would you like to do: ',
-                });
-            }
-            const rawShellCommand = await this.generateShell(userPrompt);
-            this.displayGeneratedShell(rawShellCommand);
-            await this.handleUserAction(rawShellCommand, userPrompt);
-        }
-        catch (error) {
-            console.error('Could not generate shell script', error);
-        }
-    }
-}
-exports.default = ShellManager;

package/dist/managers/StreamManager.js

@@ -1,308 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = __importDefault(require("fs"));
-const axios_1 = __importDefault(require("axios"));
-const path_1 = __importDefault(require("path"));
-const events_1 = require("events");
-const colors_1 = __importDefault(require("colors"));
-const cli_highlight_1 = __importDefault(require("cli-highlight"));
-const cloving_gpt_1 = __importDefault(require("../cloving_gpt"));
-const ChunkManager_1 = __importDefault(require("./ChunkManager"));
-const BlockManager_1 = __importDefault(require("./BlockManager"));
-const prompt_utils_1 = require("../utils/prompt_utils");
-const config_utils_1 = require("../utils/config_utils");
-const prompt_utils_2 = require("../utils/prompt_utils");
-/**
- * StreamManager class
- *
- * This class extends EventEmitter and manages the streaming of responses from an AI model.
- * It handles the processing of chunks, manages code blocks, and provides animation for code generation.
- */
-class StreamManager extends events_1.EventEmitter {
-    /**
-     * Creates an instance of StreamManager.
-     * @param {any} options - Configuration options for the StreamManager.
-     */
-    constructor(options) {
-        super();
-        this.options = options;
-        this.prompt = '';
-        this.responseString = '';
-        this.contextFiles = {};
-        this.chatHistory = [];
-        this.isProcessing = false;
-        this.animationInterval = null;
-        this.retryCount = 0;
-        this.maxRetries = 3;
-        this.gpt = new cloving_gpt_1.default(options);
-        this.chunkManager = new ChunkManager_1.default();
-        this.blockManager = new BlockManager_1.default();
-    }
-    /**
-     * Checks for the latest version of the app from GitHub and compares it with the current version.
-     * If a new version is available, it notifies the user.
-     * @private
-     * @returns {Promise<void>}
-     */
-    async checkForLatestVersion() {
-        try {
-            const response = await axios_1.default.get('https://api.github.com/repos/cloving-ai/cloving-cli/releases/latest');
-            const latestVersion = response.data.tag_name;
-            const currentVersion = `v${(0, prompt_utils_1.getPackageVersion)()}`;
-            if (latestVersion !== currentVersion) {
-                console.log(colors_1.default.bgWhite.black(`\n 🚀 A new version of Cloving is available: ${latestVersion}    `));
-                console.log(colors_1.default.bgWhite.black(`    You are currently using version: ${currentVersion}          `));
-                console.log(colors_1.default.bgWhite.black(`    To upgrade, run: ${colors_1.default.bgWhite.black.bold('npm install -g cloving@latest')}   `));
-            }
-        }
-        catch (error) {
-            // ignore errors
-        }
-    }
-    /**
-     * Handles the response stream from the AI model.
-     * @param {any} responseStream - The stream of responses from the AI model.
-     */
-    handleResponseStream(responseStream) {
-        this.responseString = '';
-        this.setupChunkManagerEvents();
-        this.setupBlockManagerEvents();
-        this.setupResponseStreamEvents(responseStream);
-    }
-    /**
-     * Sets up event listeners for the BlockManager.
-     * @private
-     */
-    setupBlockManagerEvents() {
-        this.blockManager = new BlockManager_1.default();
-        this.blockManager.on('startGeneratingCode', () => {
-            this.setupAnimationInterval();
-        });
-        this.blockManager.on('endGeneratingCode', () => {
-            this.clearAnimation();
-        });
-        this.blockManager.on('content', (content) => {
-            process.stdout.write(content);
-            this.responseString += content;
-        });
-        this.blockManager.on('codeBlock', (codeBlock) => {
-            this.handleCodeBlock(codeBlock);
-        });
-    }
-    /**
-     * Sets up an animation interval for code generation visualization.
-     * @private
-     */
-    setupAnimationInterval() {
-        process.stdout.write(colors_1.default.gray.bold('\nGenerating code...  '));
-        let animationIndex = 0;
-        const animationChars = ['/', '|', '\\', '-'];
-        this.animationInterval = setInterval(() => {
-            process.stdout.write('\b'.repeat(1));
-            process.stdout.write(colors_1.default.gray.bold(animationChars[animationIndex]));
-            animationIndex = (animationIndex + 1) % animationChars.length;
-        }, 100);
-    }
-    /**
-     * Clears the animation interval.
-     * @private
-     */
-    clearAnimation() {
-        if (!this.animationInterval)
-            return;
-        clearInterval(this.animationInterval);
-        process.stdout.write('\b'.repeat(100));
-    }
-    /**
-     * Handles the processing of a code block.
-     * @private
-     * @param {Object} codeBlock - The code block to process.
-     * @param {CurrentNewBlock} [codeBlock.currentNewBlock] - The current and new content of the code block.
-     * @param {string} [codeBlock.raw] - The raw content of the code block.
-     */
-    handleCodeBlock(codeBlock) {
-        const { currentNewBlock, raw } = codeBlock;
-        if (currentNewBlock?.currentContent && currentNewBlock?.newContent) {
-            this.displayCurrentNewBlock(currentNewBlock);
-        }
-        else if (raw) {
-            this.displayRawCodeBlock(raw);
-        }
-        else {
-            process.stdout.write(`                                       \n`);
-        }
-        this.responseString += raw || currentNewBlock;
-    }
-    /**
-     * Displays the current and new content of a code block.
-     * @private
-     * @param {CurrentNewBlock} currentNewBlock - The current and new content of the code block.
-     */
-    displayCurrentNewBlock(currentNewBlock) {
-        const language = currentNewBlock.language.split('\n')[0];
-        process.stdout.write(colors_1.default.gray.bold(`\`\`\`${language}                                       \n`));
-        process.stdout.write(colors_1.default.gray.bold(`<<<<<<< CURRENT ${currentNewBlock.filePath}\n`));
-        try {
-            process.stdout.write((0, cli_highlight_1.default)(currentNewBlock.currentContent));
-        }
-        catch (error) {
-            process.stdout.write(currentNewBlock.currentContent);
-        }
-        process.stdout.write(colors_1.default.gray.bold('\n=======\n'));
-        try {
-            process.stdout.write((0, cli_highlight_1.default)(currentNewBlock.newContent));
-        }
-        catch (error) {
-            process.stdout.write(currentNewBlock.newContent);
-        }
-        process.stdout.write(colors_1.default.gray.bold('\n>>>>>>> NEW\n```'));
-    }
-    /**
-     * Displays a raw code block.
-     * @private
-     * @param {string} raw - The raw content of the code block.
-     */
-    displayRawCodeBlock(raw) {
-        process.stdout.write(`                                       \n`);
-        process.stdout.write((0, cli_highlight_1.default)(raw));
-    }
-    /**
-     * Sets up event listeners for the ChunkManager.
-     * @private
-     */
-    setupChunkManagerEvents() {
-        this.chunkManager = new ChunkManager_1.default();
-        this.chunkManager.on('content', (buffer) => {
-            this.processChunkManagerContent(buffer);
-        });
-    }
-    /**
-     * Processes the content received from the ChunkManager.
-     * @private
-     * @param {string} buffer - The buffer containing the chunk content.
-     */
-    processChunkManagerContent(buffer) {
-        let convertedStream = this.gpt.convertStream(buffer);
-        while (convertedStream !== null) {
-            const { output, lastChar } = convertedStream;
-            this.blockManager.addContent(output);
-            this.chunkManager.clearBuffer(lastChar);
-            buffer = buffer.slice(lastChar);
-            convertedStream = this.gpt.convertStream(buffer);
-        }
-    }
-    /**
-     * Sets up event listeners for the response stream.
-     * @private
-     * @param {any} responseStream - The stream of responses from the AI model.
-     */
-    setupResponseStreamEvents(responseStream) {
-        responseStream.data.on('data', this.handleResponseStreamData.bind(this));
-        responseStream.data.on('end', () => this.finalizeResponse());
-        responseStream.data.on('error', this.handleResponseStreamError.bind(this));
-    }
-    /**
-     * Handles the data received from the response stream.
-     * @private
-     * @param {Buffer | undefined} chunk - The chunk of data received from the stream.
-     */
-    handleResponseStreamData(chunk) {
-        if (!chunk)
-            return;
-        const chunkString = chunk.toString();
-        this.chunkManager.addChunk(chunkString);
-    }
-    /**
-     * Handles errors that occur during the response stream.
-     * @private
-     * @param {Error} error - The error that occurred.
-     */
-    handleResponseStreamError(error) {
-        console.error('Error streaming response:', error);
-        this.isProcessing = false;
-        process.stdout.write('\n');
-        this.emit('prompt');
-    }
-    /**
-     * Finalizes the response processing.
-     * This method should be overridden in subclasses to provide specific finalization behavior.
-     * @protected
-     */
-    finalizeResponse() {
-        this.isProcessing = false;
-        this.emit('responseFinalized', this.responseString);
-    }
-    /**
-     * Loads context files specified in the options or defaults to the primary language's directory.
-     * @private
-     * @returns {Promise<void>}
-     */
-    async loadContextFiles() {
-        try {
-            const config = (0, config_utils_1.getNearestClovingConfig)().config;
-            const primaryLanguage = config.languages.find((lang) => lang.primary);
-            const defaultDirectory = primaryLanguage ? primaryLanguage.directory : '.';
-            const testingDirectories = config.testingFrameworks?.map((framework) => framework.directory) || [];
-            const testingDirectory = testingDirectories[0];
-            let files = this.options.files || [defaultDirectory, testingDirectory].filter(Boolean);
-            if (files.length > 0) {
-                console.log(`\nBuilding AI prompt context...\n`);
-            }
-            for (const file of files) {
-                // Skip if the file is not a string
-                if (!file)
-                    continue;
-                try {
-                    const previousCount = Object.keys(this.contextFiles).length;
-                    this.contextFiles = await (0, prompt_utils_2.addFileOrDirectoryToContext)(file, this.contextFiles, this.options);
-                    const newCount = Object.keys(this.contextFiles).length;
-                    const addedCount = newCount - previousCount;
-                    const totalTokens = this.calculateTotalTokens();
-                    console.log(colors_1.default.cyan(`📁 Loaded context from: ${colors_1.default.bold(file)}`));
-                    console.log(colors_1.default.green(`   ✅ Added ${addedCount} file(s) to context`));
-                    console.log(colors_1.default.yellow(`   📊 Total tokens in context: ${totalTokens.toLocaleString()}\n`));
-                }
-                catch (fileError) {
-                    console.error(colors_1.default.red(`Error loading context from ${file}:`), fileError);
-                }
-            }
-        }
-        catch (error) {
-            console.error(colors_1.default.red('Error loading context files:'), error);
-            throw new Error('Failed to load context files');
-        }
-    }
-    calculateTotalTokens() {
-        return Object.values(this.contextFiles).reduce((total, content) => {
-            return total + Math.ceil(content.length / 4);
-        }, 0);
-    }
-    async refreshContext() {
-        await this.reloadContextFiles();
-        const updatedSystemPrompt = (0, prompt_utils_2.generateCodegenPrompt)(this.contextFiles);
-        this.chatHistory[0] = { role: 'user', content: updatedSystemPrompt };
-        this.chatHistory[1] = { role: 'assistant', content: 'What would you like to do?' };
-    }
-    async reloadContextFiles() {
-        for (const filePath in this.contextFiles) {
-            try {
-                const content = await fs_1.default.promises.readFile(path_1.default.resolve(filePath), 'utf8');
-                this.contextFiles[filePath] = content;
-            }
-            catch (error) {
-                console.error(`Error reading file ${filePath}:`, error);
-            }
-        }
-    }
-    addUserPrompt(content) {
-        this.prompt = content;
-        this.chatHistory.push({ role: 'user', content });
-    }
-    addAssistantResponse(content) {
-        this.chatHistory.push({ role: 'assistant', content });
-    }
-}
-exports.default = StreamManager;