cloving 0.1.0 → 0.1.1-8.1

package/README.md

@@ -1,26 +1,69 @@
-# Cloving
+# Cloving - CLI Code Generation with AI
 
-Cloving is an innovative tool designed to seamlessly integrate AI into various aspects of the developer workflow. It aims to enhance productivity and code quality by leveraging AI for tasks such as generating commit messages, conducting code reviews, and creating unit tests.
+Cloving CLI is a command line utility which integrates AI into your development workflow. It provides AI-powered code generation, commit message generation, code reviews, unit test generation, and more.
+
+What makes the Cloving CLI different from other AI tools is that it builds sophisticated context-aware prompts to generate code, commit messages, and more.
+
+Cloving gets to know your specific projects, the frameworks you use, the coding style you prefer, and the patterns you follow, and does its best to generate code that fits your existing project so that it actually works.
+
+It delivers usable code that you can save directly into your project instead of copying and pasting code snippets from chat interactions.
+
+**Read the [introduction announcement](https://cloving.ai/tutorials/introducing-the-cloving-cli).**
+
+> [!WARNING]
+>
+> This project is still in the early stages of development and is not yet stable.
+> Please use it with caution and [report any issues](https://github.com/cloving-ai/cloving-cli/issues) you encounter
 
 ## Features
 
+- **Context-aware AI code generation**
 - **AI-powered Git commit message generation**
 - **Automated code reviews with AI insights**
 - **AI-assisted unit test generation**
-- **Seamless integration with existing development workflows**
-- **Customizable AI prompts for different tasks**
+- **Support for multiple AI models including OpenAI, Claude, and Ollama**
+
+## Important
+
+The cloving will ask you before submitting any prompt to the AI model. You can use the `-s` or `--silent` flag to run the command without asking for confirmation, but by default you will have the chance to review all prompts with all the context before submitting them. This is to ensure that you are aware of what is being sent to the AI model and can make any necessary changes before submitting the prompt.
 
 ## Prerequisites
 
 - Node.js (version 20 or higher)
 - Git
-- API access to AI chat models (e.g., OpenAI GPT-4o, Claude, etc.)
+- API access to AI chat models (e.g., OpenAI GPT-4, Claude, Ollama, etc.)
 
 ## Installation
 
+You have three options to install and use Cloving:
+
+### 1. Global Installation via npm
+
+Install Cloving globally using npm:
+
+```bash
+npm install cloving -g
+```
+
+This allows you to run `cloving` commands from anywhere in your terminal.
+
+### 2. Run with npx
+
+You can use npx to run Cloving without installing it globally:
+
+```bash
+npx cloving [command]
+```
+
+This method downloads and executes Cloving on-the-fly, ensuring you always use the latest version.
+
+### 3. Clone and Install from Source
+
+For development or to use the latest unreleased features:
+
 1. Clone this repository:
    ```bash
-   git clone https://github.com/clovingai/cloving-cli.git
+   git clone https://github.com/cloving-ai/cloving-cli.git
    ```
 
 2. Navigate to the project directory:
@@ -28,82 +71,167 @@ Cloving is an innovative tool designed to seamlessly integrate AI into various a
    cd cloving-cli
    ```
 
-3. Install dependencies:
+3. Install dependencies and link the package:
    ```bash
    yarn install
+   yarn link
    ```
 
-4. Set up your AI chat model environment variables:
-   ```bash
-   export CLOVING_MODEL=your_preferred_model
-   export CLOVING_API_KEY=your_api_key
-   ```
+After installation, configure Cloving with your API key and preferred model:
+
+```bash
+cloving config
+```
+
+Choose the installation method that best suits your needs and workflow. The global npm installation is recommended for most users, while npx is great for one-off usage or trying out Cloving. Cloning from source is ideal for contributors or those who want the absolute latest features.
 
 ## Usage
 
 Cloving provides several commands to help integrate AI into your development workflow:
 
+### Configuration
+
+Configure Cloving with your API key and model:
+```bash
+cloving config
+```
+
+### Initialization
+
+Set up Cloving in the current project:
+```bash
+cloving init
+```
+Options:
+- `-s, --silent`: Run without asking for confirmation of submitting prompts
+- `-m, --model <model>`: Select the model to use
+
 ### Generating Commit Messages
 
-Run the following command in your Git repository:
+Generate an AI-powered commit message:
 ```bash
 cloving commit
 ```
-This will generate an AI-powered commit message based on your recent changes, allow you to review and edit it, and then commit your changes.
+or
+```bash
+cloving generate commit
+```
+Options:
+- `-s, --silent`: Run without asking for confirmation
+- `-m, --model <model>`: Select the model to use
 
 ### Code Reviews
 
-To get an AI-powered code review for your latest changes:
+Get an AI-powered code review:
 ```bash
-cloving review
+cloving generate review
 ```
+Options:
+- `-s, --silent`: Run without asking for confirmation
+- `-m, --model <model>`: Select the model to use
 
-### Generating Unit Tests
+### Generating Code
 
-To generate unit tests for a specific file or function:
+Generate code based on a prompt:
 ```bash
-cloving unit-tests [file_path_to_test]
+cloving generate code
 ```
+Options:
+- `--save`: Automatically save all files after generating the code
+- `-i, --interactive`: Auto-save generated code and then show a new prompt with existing context to revise the code further
+- `-s, --silent`: Run the command without asking for confirmation of submitting prompts
+- `-m, --model <model>`: Select the model to use
+- `-p, --prompt <prompt>`: Specify the prompt to use
+- `-f, --files <filenames...>`: Specify filenames of files with context to use for generating code
 
-### Initial Setup
+### Generating Shell Commands
 
-To set up Cloving in the current project, generating a `cloving.json` file that includes a GPT-generated project overview with details like the language, framework, and language version:
+Generate a shell command based on a prompt:
 ```bash
-cloving init
+cloving generate shell
 ```
+or
+```bash
+cloving generate sh
+```
+Options:
+- `-s, --silent`: Run without asking for confirmation of submitting prompts
+- `-m, --model <model>`: Select the model to use
+- `-p, --prompt <prompt>`: Specify the prompt to use
 
-### Configuration
+### Generating Context
 
-To configure Cloving with your API key and model:
+Create a context string for generating prompts outside of the cloving cli:
 ```bash
-cloving config
+cloving generate context
 ```
+Options:
+- `-f, --files <filenames...>`: Specify filenames of files with context
 
-### Listing Available Models
+### Generating Unit Tests
 
-To list the available AI models:
+Generate unit tests for changes or specific files:
 ```bash
-cloving models
+cloving generate unit-tests
 ```
+Options:
+- `-s, --silent`: Run without asking for confirmation
+- `-f, --files <filenames...>`: Specify filenames for the unit tests
+- `-m, --model <model>`: Select the model to use
 
-## Command Line Options
+### Project Commands
+
+Cloving now includes commands for managing entire projects:
+
+- Initialize a new project inside a git branch:
+  ```bash
+  cloving project init
+  ```
+
+- Plan the steps to complete the project:
+  ```bash
+  cloving project plan
+  ```
 
-Usage: `cloving [options] [command]`
+- Generate code to build the project:
+  ```bash
+  cloving project build
+  ```
+
+- Clean up and finalize the project:
+  ```bash
+  cloving project complete
+  ```
+
+## Command Line Options
 
-Integrate AI into your development workflow for generating commit messages, code reviews, and unit tests.
+Usage: `cloving [command] [options]`
 
 Options:
-- `-V, --version`   output the version number
-- `-h, --help`      display help for command
+- `-V, --version`: Output the version number
+- `-h, --help`: Display help for command
 
 Commands:
-- `commit`          Generate a commit message and commit the changes
-- `unit-tests`      Generate unit tests for the changes
-- `models`          List available models
-- `review`          Review the changes and propose
-- `init`            Setup Cloving in the current project
-- `config`          Configure Cloving with your API key and model
-- `help [command]`  Display help for command
+- `config`: Configure Cloving with your API key and models to use
+- `init`: Setup Cloving in the current directory
+- `models`: List available models
+- `commit`: Alias for cloving generate commit
+- `generate`: Generate various items like unit-tests and code reviews
+  - `commit`: Generate a commit message and commit the changes
+  - `code`: Generate code based on a prompt
+  - `context`: Generate context for building a prompt outside of cloving
+  - `shell`: Generate a shell command based on a prompt
+  - `unit-tests`: Generate unit tests
+  - `review`: Review the code for committed changes
+- `project`: Commands for managing Cloving projects
+  - `init`: Setup a new Cloving project inside a git branch
+  - `plan`: Plan the steps to complete the project
+  - `build`: Generate code to build the project
+  - `complete`: Clean up and finalize the project
+
+Most commands support the following options:
+- `-s, --silent`: Run the command without asking for confirmation of submitting prompts
+- `-m, --model <model>`: Select the model to use (e.g., openai, claude, ollama, ollama:llama3, claude:claude-3-5-sonnet-20240620)
 
 ## Contributing
 

package/dist/cloving_gpt/adapters/claude.js

@@ -23,13 +23,13 @@ class ClaudeAdapter {
     }
     getPayload(request) {
         return {
-            model: this.model,
+            model: this.model.replace(':', '-'),
             system: 'You are a computer programmer giving advice on how to write better code.',
             messages: [
                 { role: 'user', content: request.prompt }
             ],
             max_tokens: request.maxTokens || 4096,
-            temperature: request.temperature || 0.7
+            temperature: request.temperature || 0.2
         };
     }
     extractResponse(data) {
@@ -50,11 +50,9 @@ class ClaudeAdapter {
 }
 exports.ClaudeAdapter = ClaudeAdapter;
 ClaudeAdapter.supportedModels = [
-    'claude:claude-3-5-sonnet-20240620',
-    'claude:claude-3-opus-20240229',
-    'claude:claude-3-sonnet-20240229',
-    'claude:claude-3-haiku-20240307',
+    'claude:claude-3-5:sonnet-20240620',
+    'claude:claude-3:opus-20240229',
+    'claude:claude-3:sonnet-20240229',
+    'claude:claude-3:haiku-20240307',
     // Add more supported models here as needed
 ];
-// Example usage:
-// ClaudeAdapter.listSupportedModels()

package/dist/cloving_gpt/adapters/gemini.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiAdapter = void 0;
+class GeminiAdapter {
+    constructor(model) {
+        this.model = model;
+    }
+    static async listSupportedModels() {
+        GeminiAdapter.supportedModels.forEach(model => {
+            console.log(model);
+        });
+    }
+    getEndpoint() {
+        return `https://generativelanguage.googleapis.com/v1beta/models/${this.model.replace(':', '-')}:generateContent`;
+    }
+    getHeaders(apiKey) {
+        return {
+            'Content-Type': 'application/json',
+            'x-goog-api-key': apiKey
+        };
+    }
+    getPayload(request) {
+        return {
+            contents: [
+                {
+                    parts: [
+                        {
+                            text: request.prompt
+                        }
+                    ]
+                }
+            ],
+            generationConfig: {
+                temperature: 0.2,
+                topK: 40,
+                topP: 0.95,
+                maxOutputTokens: 1024
+            }
+        };
+    }
+    extractResponse(data) {
+        try {
+            if (data && data.candidates && data.candidates[0] && data.candidates[0].content && data.candidates[0].content.parts && data.candidates[0].content.parts[0]) {
+                return data.candidates[0].content.parts[0].text;
+            }
+            else {
+                console.error('Unexpected response structure:', data);
+                throw new Error('Invalid response structure');
+            }
+        }
+        catch (error) {
+            console.error('Error extracting response:', error);
+            throw error;
+        }
+    }
+}
+exports.GeminiAdapter = GeminiAdapter;
+GeminiAdapter.supportedModels = [
+    'gemini:gemini-1.5:pro-latest',
+    'gemini:gemini-1.5:flash-latest',
+    'gemini:gemini-1.0:pro-latest',
+];

package/dist/cloving_gpt/adapters/mistral.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MistralAdapter = void 0;
+class MistralAdapter {
+    static listSupportedModels() {
+        MistralAdapter.supportedModels.forEach(model => {
+            console.log(model);
+        });
+    }
+    constructor(model) {
+        this.model = model;
+    }
+    getEndpoint() {
+        return 'https://api.mistral.ai/v1/chat/completions';
+    }
+    getHeaders(apiKey) {
+        return {
+            'Authorization': `Bearer ${apiKey}`,
+            'Content-Type': 'application/json'
+        };
+    }
+    getPayload(request) {
+        return {
+            model: this.model.replace(':', '-'),
+            messages: [{ role: "user", content: request.prompt }],
+            max_tokens: request.maxTokens,
+            temperature: request.temperature || 0.2,
+            stream: false
+        };
+    }
+    extractResponse(data) {
+        return data.choices[0].message.content;
+    }
+}
+exports.MistralAdapter = MistralAdapter;
+MistralAdapter.supportedModels = [
+    'mistral:mistral:embed',
+    'mistral:mistral:tiny-latest',
+    'mistral:mistral:small-latest',
+    'mistral:mistral:medium-latest',
+    'mistral:mistral:large-latest',
+    'mistral:open-mistral:7b',
+    'mistral:open-mixtral:8x7b',
+    'mistral:open-mixtral:8x22b',
+    'mistral:codestral:latest',
+];

package/dist/cloving_gpt/adapters/openai.js

@@ -21,10 +21,10 @@ class OpenAIAdapter {
     }
     getPayload(request) {
         return {
-            model: this.model,
+            model: this.model.replace(':', '-'),
             messages: [{ role: "user", content: request.prompt }],
             max_tokens: request.maxTokens,
-            temperature: request.temperature || 0.7
+            temperature: request.temperature || 0.2
         };
     }
     extractResponse(data) {
@@ -33,9 +33,10 @@ class OpenAIAdapter {
 }
 exports.OpenAIAdapter = OpenAIAdapter;
 OpenAIAdapter.supportedModels = [
-    'openai:gpt-4o',
-    'openai:gpt-4-turbo',
-    'openai:gpt-3.5-turbo',
-    'openai:text-embedding-3-large',
+    'openai:gpt:4o',
+    'openai:gpt:4o-mini',
+    'openai:gpt:4-turbo',
+    'openai:gpt:3.5-turbo',
+    'openai:text-embedding:3-large',
     // Add more supported models here as needed
 ];

package/dist/cloving_gpt/index.js

@@ -4,98 +4,99 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const axios_1 = __importDefault(require("axios"));
-const readline_1 = __importDefault(require("readline"));
 const child_process_1 = require("child_process");
 const process_1 = __importDefault(require("process"));
+const prompts_1 = require("@inquirer/prompts");
 const claude_1 = require("./adapters/claude");
 const openai_1 = require("./adapters/openai");
-const gpt4all_1 = require("./adapters/gpt4all");
+const mistral_1 = require("./adapters/mistral");
 const ollama_1 = require("./adapters/ollama");
-const command_utils_1 = require("../utils/command_utils");
+const gemini_1 = require("./adapters/gemini");
+const config_utils_1 = require("../utils/config_utils");
 class ClovingGPT {
-    constructor(options = { silent: false }) {
-        const config = (0, command_utils_1.getConfig)();
-        if (!config || !config.primaryModel || !config.models) {
-            throw new Error('No cloving configuration found. Please run `cloving config`');
+    constructor(options) {
+        const { model: partialModel } = options;
+        const config = (0, config_utils_1.getConfig)(options);
+        if (!config || !config.models) {
+            console.log('No cloving configuration found. Please run: cloving config');
+            process_1.default.exit(1);
         }
-        const clovingModel = config.primaryModel;
-        this.apiKey = config.models[config?.primaryModel || ''].trim();
-        this.silent = options.silent;
-        const parts = clovingModel.split(':');
-        const model = parts.slice(1).join(':');
-        switch (parts[0]) {
+        const primaryModel = (0, config_utils_1.getPrimaryModel)(partialModel);
+        if (!primaryModel) {
+            console.log('No AI API models found in the cloving configuration. Please run: cloving config');
+            process_1.default.exit(1);
+        }
+        const { provider, model, config: modelConfig } = primaryModel;
+        this.apiKey = modelConfig.apiKey;
+        this.temperature = options.temperature || modelConfig.temperature || 0.2;
+        this.silent = options.silent || modelConfig.silent;
+        switch (provider) {
             case 'claude':
                 this.adapter = new claude_1.ClaudeAdapter(model);
                 break;
             case 'openai':
                 this.adapter = new openai_1.OpenAIAdapter(model);
                 break;
-            case 'gpt4all':
-                this.adapter = new gpt4all_1.GPT4AllAdapter(model);
+            case 'mistral':
+                this.adapter = new mistral_1.MistralAdapter(model);
                 break;
             case 'ollama':
                 this.adapter = new ollama_1.OllamaAdapter(model);
                 break;
+            case 'gemini':
+                this.adapter = new gemini_1.GeminiAdapter(model);
+                break;
             default:
-                throw new Error(`Unsupported provider: ${parts[0]}`);
+                throw new Error(`Unsupported provider: ${provider}`);
         }
     }
-    async askUserToConfirm(prompt, message) {
+    async reviewPrompt(prompt, endpoint) {
         if (this.silent)
-            return true;
-        const rl = readline_1.default.createInterface({
-            input: process_1.default.stdin,
-            output: process_1.default.stdout
+            return;
+        const tokenCount = Math.ceil(prompt.length / 4).toLocaleString();
+        const reviewPrompt = await (0, prompts_1.confirm)({
+            message: `Do you want to review the ~${tokenCount} token prompt before sending it to ${endpoint}?`,
+            default: true
         });
-        return new Promise((resolve) => {
-            rl.question(message, (answer) => {
-                rl.close();
-                answer = answer.trim().toLowerCase();
-                if (answer === 'y' || answer === '') {
-                    const less = (0, child_process_1.spawn)('less', ['-R'], { stdio: ['pipe', process_1.default.stdout, process_1.default.stderr] });
-                    less.stdin.write(prompt);
-                    less.stdin.end();
-                    less.on('close', (code) => {
-                        if (code !== 0) {
-                            console.error('less command exited with an error.');
-                            resolve(false);
-                            return;
-                        }
-                        const rlConfirm = readline_1.default.createInterface({
-                            input: process_1.default.stdin,
-                            output: process_1.default.stdout
-                        });
-                        rlConfirm.question('Do you still want to continue? [Yn]: ', (confirmAnswer) => {
-                            rlConfirm.close();
-                            confirmAnswer = confirmAnswer.trim().toLowerCase();
-                            resolve(confirmAnswer === 'y' || confirmAnswer === '');
-                        });
-                    });
-                    less.stdin.on('error', (err) => {
-                        if (isNodeError(err) && err.code === 'EPIPE') {
-                            resolve(true);
-                        }
-                        else {
-                            console.error('Pipeline error:', err);
-                            resolve(false);
-                        }
+        if (reviewPrompt) {
+            const less = (0, child_process_1.spawn)('less', ['-R'], { stdio: ['pipe', process_1.default.stdout, process_1.default.stderr] });
+            less.stdin.write(prompt);
+            less.stdin.end();
+            await new Promise((resolve, reject) => {
+                less.on('close', async (code) => {
+                    if (code !== 0) {
+                        console.error('less command exited with an error');
+                        reject(new Error('Less command failed'));
+                        return;
+                    }
+                    const confirmContinue = await (0, prompts_1.confirm)({
+                        message: 'Do you want to continue?',
+                        default: true
                     });
-                }
-                else {
-                    resolve(true);
-                }
+                    if (!confirmContinue) {
+                        console.error('Operation cancelled');
+                        process_1.default.exit(1);
+                    }
+                    resolve();
+                });
+                less.stdin.on('error', (err) => {
+                    if (isNodeError(err) && err.code === 'EPIPE') {
+                        resolve();
+                    }
+                    else {
+                        console.error('Pipeline error:', err);
+                        reject(err);
+                    }
+                });
             });
-        });
+        }
     }
     async generateText(request) {
+        request.temperature || (request.temperature = this.temperature);
         const endpoint = this.adapter.getEndpoint();
         const payload = this.adapter.getPayload(request);
         const headers = this.adapter.getHeaders(this.apiKey);
-        const tokenCount = Math.ceil(request.prompt.length / 4).toLocaleString();
-        const shouldContinue = await this.askUserToConfirm(request.prompt, `Do you want to review the ~${tokenCount} token prompt before sending it to ${endpoint}? [Yn]: `);
-        if (!shouldContinue) {
-            throw 'Operation cancelled by the user.';
-        }
+        await this.reviewPrompt(request.prompt, endpoint);
         try {
             const response = await axios_1.default.post(endpoint, payload, { headers });
             return this.adapter.extractResponse(response.data);

package/dist/commands/commit.js

@@ -8,10 +8,10 @@ const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
 const git_utils_1 = require("../utils/git_utils");
 const string_utils_1 = require("../utils/string_utils");
-const command_utils_1 = require("../utils/command_utils");
+const config_utils_1 = require("../utils/config_utils");
 const cloving_gpt_1 = __importDefault(require("../cloving_gpt"));
 const generateAndCommitMessage = async (options) => {
-    options.silent = (0, command_utils_1.getConfig)().silent || false;
+    options.silent = (0, config_utils_1.getConfig)(options).globalSilent || false;
     const gpt = new cloving_gpt_1.default(options);
     try {
         // Generate the prompt for commit message