cloving 0.3.11 → 0.3.13

package/dist/managers/StreamManager.js

@@ -0,0 +1,308 @@
+"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, { language }));
+        }
+        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, { language }));
+        }
+        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.getClovingConfig)();
+            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;

package/dist/managers/UnitTestManager.js

@@ -8,7 +8,7 @@ const child_process_1 = require("child_process");
 const cli_highlight_1 = __importDefault(require("cli-highlight"));
 const prompts_1 = require("@inquirer/prompts");
 const git_utils_1 = require("../utils/git_utils");
-const prompt_utils_1 = require("../utils/prompt_utils");
+const prompts_2 = require("../utils/prompts");
 const config_utils_1 = require("../utils/config_utils");
 const string_utils_1 = require("../utils/string_utils");
 const cloving_gpt_1 = __importDefault(require("../cloving_gpt"));
@@ -197,7 +197,7 @@ Also, list any test files that might be relevant to these files.`;
 ## List of Files
 ${(files || []).join('\n')}
 
-${prompt_utils_1.CODEGEN_INSTRUCTIONS}
+${prompts_2.CODEGEN_INSTRUCTIONS}
 
 ## Context
 
@@ -221,7 +221,7 @@ ${await (0, git_utils_1.getGitDiff)()}
 
 ${context.join('\n\n')}
 
-${prompt_utils_1.CODEGEN_INSTRUCTIONS}
+${prompts_2.CODEGEN_INSTRUCTIONS}
 
 ## Prompt
 

package/dist/package.json

@@ -1,11 +1,11 @@
 {
   "name": "cloving",
-  "version": "0.3.11",
+  "version": "0.3.13",
   "packageManager": "yarn@1.22.22",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
-    "build": "tsc && cp package.json dist/package.json",
+    "build": "tsc && cp package.json dist/package.json && cp src/utils/prompts/*.md dist/utils/prompts/",
     "start": "node dist/index.js",
     "watch": "tsc -w",
     "check": "bash -c 'npx tsc --noEmit --skipLibCheck'",

package/dist/utils/config_utils.js

@@ -1,4 +1,8 @@
 "use strict";
+/**
+ * @file Configuration utilities for Cloving
+ * @module config_utils
+ */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -10,10 +14,19 @@ const fs_1 = __importDefault(require("fs"));
 const ini_1 = __importDefault(require("ini"));
 const child_process_1 = require("child_process");
 const cloving_gpt_1 = __importDefault(require("../cloving_gpt"));
+/** Path to the global Cloving configuration file */
 exports.CLOVING_CONFIG_PATH = path_1.default.join(os_1.default.homedir(), '.clovingconfig');
+/** Name of the local Cloving configuration file */
 exports.CLOVINGFILE_PATH = 'cloving.json';
+/** Path to the Cloving projects directory */
 exports.CLOVINGPROJECT_PATH = '.clovingprojects';
+/** Cached Cloving configuration */
 let clovingConfig;
+/**
+ * Retrieves the Cloving configuration
+ * @param {ClovingGPTOptions} options - Options for ClovingGPT
+ * @returns {ClovingConfig} The Cloving configuration
+ */
 const getConfig = (options) => {
     try {
         if (fs_1.default.existsSync(exports.CLOVING_CONFIG_PATH)) {
@@ -38,6 +51,7 @@ const getConfig = (options) => {
     catch (err) {
         console.error('Error reading configuration:', err);
     }
+    // Fallback to environment variables if config file doesn't exist
     if (process.env.CLOVING_MODEL) {
         const [provider, ...modelParts] = process.env.CLOVING_MODEL.split(':');
         const model = modelParts.join(':');
@@ -62,6 +76,11 @@ const getConfig = (options) => {
     }
 };
 exports.getConfig = getConfig;
+/**
+ * Retrieves the local Cloving configuration
+ * @returns {ClovingfileConfig} The local Cloving configuration
+ * @throws {Error} If the cloving.json file is not found
+ */
 const getClovingConfig = () => {
     if (clovingConfig) {
         return clovingConfig;
@@ -77,12 +96,21 @@ const getClovingConfig = () => {
     }
 };
 exports.getClovingConfig = getClovingConfig;
+/**
+ * Saves the Cloving configuration to the config file
+ * @param {ClovingConfig} config - The configuration to save
+ */
 const saveConfig = (config) => {
     const iniString = ini_1.default.stringify(config);
     fs_1.default.writeFileSync(exports.CLOVING_CONFIG_PATH, iniString);
     console.log(`Configuration saved to ${exports.CLOVING_CONFIG_PATH}`);
 };
 exports.saveConfig = saveConfig;
+/**
+ * Retrieves the primary model configuration
+ * @param {string} [partialModel] - Partial model name to filter by
+ * @returns {Object | null} The primary model configuration or null if not found
+ */
 const getPrimaryModel = (partialModel) => {
     try {
         const config = (0, exports.getConfig)({});
@@ -107,6 +135,12 @@ const getPrimaryModel = (partialModel) => {
     }
 };
 exports.getPrimaryModel = getPrimaryModel;
+/**
+ * Retrieves the configuration for a specific project
+ * @param {string} name - The name of the project
+ * @returns {ProjectConfig} The project configuration
+ * @throws {Error} If the project configuration file is not found
+ */
 const getProjectConfig = (name) => {
     const projectConfigPath = path_1.default.join(exports.CLOVINGPROJECT_PATH, name, 'config.ini');
     if (fs_1.default.existsSync(projectConfigPath)) {
@@ -118,6 +152,11 @@ const getProjectConfig = (name) => {
     }
 };
 exports.getProjectConfig = getProjectConfig;
+/**
+ * Saves the configuration for a specific project
+ * @param {string} name - The name of the project
+ * @param {ProjectConfig} config - The project configuration to save
+ */
 const saveProjectConfig = (name, config) => {
     const projectConfigPath = path_1.default.join(exports.CLOVINGPROJECT_PATH, name, 'config.ini');
     const projectConfigDir = path_1.default.dirname(projectConfigPath);
@@ -130,6 +169,10 @@ const saveProjectConfig = (name, config) => {
     console.log(`Configuration saved to ${projectConfigPath}`);
 };
 exports.saveProjectConfig = saveProjectConfig;
+/**
+ * Removes the configuration file for a specific project
+ * @param {string} name - The name of the project
+ */
 const removeProjectConfig = (name) => {
     const projectConfigPath = path_1.default.join(exports.CLOVINGPROJECT_PATH, name, 'config.ini');
     if (fs_1.default.existsSync(projectConfigPath)) {

package/dist/utils/git_utils.js

@@ -1,4 +1,8 @@
 "use strict";
+/**
+ * @module git_utils
+ * @description Provides utility functions for Git operations and commit message generation.
+ */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -6,6 +10,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateCommitMessagePrompt = exports.getCurrentBranchName = exports.getDefaultBranchName = exports.getGitDiff = void 0;
 const child_process_1 = require("child_process");
 const readline_1 = __importDefault(require("readline"));
+/**
+ * Prompts the user with a question and returns their answer.
+ * @param {string} question - The question to ask the user.
+ * @returns {Promise<string>} A promise that resolves with the user's answer.
+ */
 const askQuestion = (question) => {
     const rl = readline_1.default.createInterface({
         input: process.stdin,
@@ -16,6 +25,11 @@ const askQuestion = (question) => {
         resolve(answer);
     }));
 };
+/**
+ * Retrieves the Git diff between the current branch and the default branch.
+ * @returns {Promise<string>} A promise that resolves with the indented Git diff.
+ * @throws {Error} If there's an error getting the Git diff.
+ */
 const getGitDiff = async () => {
     try {
         const defaultBranchName = await (0, exports.getDefaultBranchName)();
@@ -33,6 +47,11 @@ const getGitDiff = async () => {
     }
 };
 exports.getGitDiff = getGitDiff;
+/**
+ * Determines the default branch name for the Git repository.
+ * @returns {Promise<string>} A promise that resolves with the default branch name.
+ * @throws {Error} If the default branch cannot be determined.
+ */
 const getDefaultBranchName = async () => {
     let defaultBranchName = (0, child_process_1.execSync)("git symbolic-ref refs/remotes/origin/HEAD | sed 's@^refs/remotes/origin/@@'")
         .toString()
@@ -54,6 +73,11 @@ const getDefaultBranchName = async () => {
     return defaultBranchName;
 };
 exports.getDefaultBranchName = getDefaultBranchName;
+/**
+ * Retrieves the name of the current Git branch.
+ * @returns {string} The name of the current Git branch.
+ * @throws {Error} If there's an error getting the current branch name.
+ */
 const getCurrentBranchName = () => {
     try {
         return (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD').toString().trim();
@@ -64,6 +88,11 @@ const getCurrentBranchName = () => {
     }
 };
 exports.getCurrentBranchName = getCurrentBranchName;
+/**
+ * Generates a prompt for creating a commit message based on a Git diff.
+ * @param {string} diff - The Git diff to base the commit message on.
+ * @returns {string} A prompt string for generating a commit message.
+ */
 const generateCommitMessagePrompt = (diff) => {
     return `Generate a concise and meaningful commit message based on a diff.