cloving 0.1.20 → 0.1.22

package/dist/managers/ChatManager.js

@@ -0,0 +1,283 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const copy_paste_1 = __importDefault(require("copy-paste"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const readline_1 = __importDefault(require("readline"));
+const child_process_1 = require("child_process");
+const ChunkManager_1 = __importDefault(require("./ChunkManager"));
+const cloving_gpt_1 = __importDefault(require("../cloving_gpt"));
+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 PREAMBLE = `Don't apologize and when generating code, always include filenames in bold with paths to the code files mentioned and do not be lazy and ask me to keep the existing code or show things like previous code remains unchanged, always include existing code in the response.`;
+class ChatManager {
+    constructor(options) {
+        this.options = options;
+        this.chatHistory = [];
+        this.commandHistory = [];
+        this.historyIndex = -1;
+        this.multilineInput = '';
+        this.isMultilineMode = false;
+        this.contextFiles = {};
+        this.prompt = '';
+        options.stream = true;
+        options.silent = true;
+        this.gpt = new cloving_gpt_1.default(options);
+        this.rl = readline_1.default.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            prompt: 'cloving> ',
+            historySize: 1000,
+        });
+        this.chunkManager = new ChunkManager_1.default();
+    }
+    async initialize() {
+        console.log('Welcome to Cloving REPL. Type "exit" to quit.');
+        this.rl.prompt();
+        this.setupEventListeners();
+        await this.loadContextFiles();
+    }
+    setupEventListeners() {
+        this.rl.on('line', this.handleLine.bind(this));
+        this.rl.on('close', this.handleClose.bind(this));
+        process.stdin.on('keypress', this.handleKeypress.bind(this));
+    }
+    async loadContextFiles() {
+        let files = this.options.files || '.';
+        let expandedFiles = [];
+        for (const file of files) {
+            const filePath = path_1.default.resolve(file);
+            if (await fs_1.default.promises.stat(filePath).then(stat => stat.isDirectory()).catch(() => false)) {
+                const dirFiles = await (0, command_utils_1.getAllFilesInDirectory)(filePath);
+                expandedFiles = expandedFiles.concat(dirFiles.map(f => path_1.default.relative(process.cwd(), f)));
+            }
+            else {
+                expandedFiles.push(path_1.default.relative(process.cwd(), filePath));
+            }
+        }
+        files = expandedFiles;
+        for (const file of files) {
+            const filePath = path_1.default.resolve(file);
+            if (await fs_1.default.promises.stat(filePath).then(stat => stat.isFile()).catch(() => false)) {
+                const content = await fs_1.default.promises.readFile(filePath, 'utf-8');
+                this.contextFiles[file] = content;
+            }
+        }
+    }
+    async handleLine(line) {
+        if (this.isMultilineMode) {
+            if (line.trim() === '```') {
+                this.isMultilineMode = false;
+                line = this.multilineInput;
+                this.multilineInput = '';
+            }
+            else {
+                this.multilineInput += line + '\n';
+                this.rl.prompt();
+                return;
+            }
+        }
+        else if (line.trim() === '```') {
+            this.isMultilineMode = true;
+            this.multilineInput = '';
+            console.log('Entering multiline mode. Type ``` on a new line to end.');
+            this.rl.prompt();
+            return;
+        }
+        const trimmedLine = line.trim().toLowerCase();
+        if (trimmedLine === '') {
+            this.rl.prompt();
+            return;
+        }
+        this.updateCommandHistory(trimmedLine);
+        if (trimmedLine === 'exit') {
+            this.rl.close();
+            return;
+        }
+        await this.handleCommand(trimmedLine);
+    }
+    updateCommandHistory(command) {
+        if (this.commandHistory[0] !== command) {
+            this.commandHistory.unshift(command);
+            if (this.commandHistory.length > 1000) {
+                this.commandHistory.pop();
+            }
+        }
+        this.historyIndex = -1;
+    }
+    async handleCommand(command) {
+        switch (command) {
+            case 'copy':
+                await this.handleCopy();
+                break;
+            case 'save':
+                await this.handleSave();
+                break;
+            case 'commit':
+                await this.handleCommit();
+                break;
+            default:
+                if (this.isGitCommand(command)) {
+                    this.executeGitCommand(command);
+                }
+                else {
+                    await this.processUserInput(command);
+                }
+        }
+    }
+    async handleCopy() {
+        const lastResponse = this.chatHistory.filter(msg => msg.role === 'assistant').pop();
+        if (lastResponse) {
+            copy_paste_1.default.copy(lastResponse.content, () => {
+                console.info('Last response copied to clipboard.');
+            });
+        }
+        else {
+            console.error('No response to copy.');
+        }
+    }
+    async handleSave() {
+        const lastResponse = this.chatHistory.filter(msg => msg.role === 'assistant').pop();
+        if (lastResponse) {
+            const [files, fileContents] = (0, string_utils_1.extractFilesAndContent)(lastResponse.content);
+            if (files.length > 0) {
+                await (0, string_utils_1.saveGeneratedFiles)(files, fileContents);
+                console.info('Files have been saved.');
+            }
+            else {
+                console.info('No files found to save in the last response.');
+            }
+        }
+        else {
+            console.error('No response to save files from.');
+        }
+    }
+    async handleCommit() {
+        const diff = (0, child_process_1.execSync)('git diff HEAD').toString().trim();
+        if (!diff) {
+            console.error('No changes to commit.');
+            return;
+        }
+        this.prompt = (0, git_utils_1.generateCommitMessagePrompt)(diff);
+        this.gpt.stream = false;
+        const rawCommitMessage = await this.gpt.generateText({ prompt: this.prompt });
+        this.gpt.stream = true;
+        const commitMessage = (0, string_utils_1.extractMarkdown)(rawCommitMessage);
+        const tempCommitFilePath = path_1.default.join('.git', 'SUGGESTED_COMMIT_EDITMSG');
+        fs_1.default.writeFileSync(tempCommitFilePath, commitMessage);
+        try {
+            (0, child_process_1.execFileSync)('git', ['commit', '-a', '--edit', '--file', tempCommitFilePath], { stdio: 'inherit' });
+        }
+        catch (commitError) {
+            console.error('Commit was canceled or failed.');
+        }
+        fs_1.default.unlink(tempCommitFilePath, (err) => {
+            if (err)
+                throw err;
+        });
+    }
+    isGitCommand(command) {
+        return command.split(' ').length <= 3 && command.startsWith('git ');
+    }
+    executeGitCommand(command) {
+        try {
+            (0, child_process_1.execSync)(command, { stdio: 'inherit' });
+        }
+        catch (error) {
+            console.error('Error running command:', error);
+        }
+    }
+    async processUserInput(input) {
+        try {
+            this.chatHistory.push({ role: 'user', content: input });
+            this.prompt = this.generatePrompt(input);
+            const responseStream = await this.gpt.streamText({ prompt: this.prompt });
+            let accumulatedContent = '';
+            this.chunkManager.on('content', (buffer) => {
+                let convertedStream = this.gpt.convertStream(buffer);
+                while (convertedStream !== null) {
+                    const { output, lastChar } = convertedStream;
+                    process.stdout.write(output);
+                    accumulatedContent += output;
+                    this.chunkManager.clearBuffer(lastChar);
+                    buffer = buffer.slice(lastChar);
+                    convertedStream = this.gpt.convertStream(buffer);
+                }
+            });
+            responseStream.data.on('data', (chunk) => {
+                const chunkString = chunk.toString();
+                this.chunkManager.addChunk(chunkString);
+            });
+            responseStream.data.on('end', () => {
+                this.chatHistory.push({ role: 'assistant', content: accumulatedContent.trim() });
+                this.rl.prompt();
+            });
+            responseStream.data.on('error', (error) => {
+                console.error('Error streaming response:', error);
+                this.rl.prompt();
+            });
+        }
+        catch (err) {
+            const error = err;
+            let errorMessage = error.message || 'An error occurred.';
+            const errorNumber = error.response?.status || 'unknown';
+            // switch case
+            switch (errorNumber) {
+                case 400:
+                    errorMessage = "Invalid model or prompt size too large. Try specifying fewer files.";
+                    break;
+                case 403:
+                    errorMessage = "Inactive subscription or usage limit reached";
+                    break;
+                case 429:
+                    errorMessage = "Rate limit error";
+                    break;
+                case 500:
+                    errorMessage = "Internal server error";
+                    break;
+            }
+            // get token estimate for prompt
+            const promptTokens = Math.ceil(this.prompt.length / 4).toLocaleString();
+            console.error(`Error processing a ${promptTokens} token prompt:`, errorMessage, `(${errorNumber})`);
+            this.rl.prompt();
+        }
+    }
+    generatePrompt(input) {
+        const contextFileContents = Object.keys(this.contextFiles)
+            .map((file) => `### Contents of ${file}\n\n${this.contextFiles[file]}\n\n`)
+            .join('\n');
+        return `${contextFileContents}
+
+### Task
+
+${PREAMBLE}
+
+${this.chatHistory.map(msg => `${msg.role.toUpperCase()}: ${msg.content}`).join('\n\n')}`;
+    }
+    handleClose() {
+        console.log('Goodbye!');
+        process.exit(0);
+    }
+    handleKeypress(_, key) {
+        if (key && (key.name === 'up' || key.name === 'down')) {
+            if (key.name === 'up' && this.historyIndex < this.commandHistory.length - 1) {
+                this.historyIndex++;
+            }
+            else if (key.name === 'down' && this.historyIndex > -1) {
+                this.historyIndex--;
+            }
+            if (this.historyIndex >= 0) {
+                this.rl.write(null, { ctrl: true, name: 'u' });
+                this.rl.write(this.commandHistory[this.historyIndex]);
+            }
+            else if (this.historyIndex === -1) {
+                this.rl.write(null, { ctrl: true, name: 'u' });
+            }
+        }
+    }
+}
+exports.default = ChatManager;

package/dist/managers/ChunkManager.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = require("events");
+class ChunkManager extends events_1.EventEmitter {
+    constructor() {
+        super(...arguments);
+        this.buffer = '';
+    }
+    addChunk(chunk) {
+        this.buffer += chunk;
+        this.emit('content', this.buffer);
+    }
+    clearBuffer(lastChar) {
+        this.buffer = this.buffer.substring(lastChar);
+    }
+    getBuffer() {
+        return this.buffer;
+    }
+}
+exports.default = ChunkManager;

package/dist/managers/CodeManager.js

@@ -0,0 +1,319 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const copy_paste_1 = __importDefault(require("copy-paste"));
+const prompts_1 = require("@inquirer/prompts");
+const cli_highlight_1 = __importDefault(require("cli-highlight"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const command_utils_1 = require("../utils/command_utils");
+const config_utils_1 = require("../utils/config_utils");
+const string_utils_1 = require("../utils/string_utils");
+class CodeManager {
+    constructor(gpt, options, allSrcFiles) {
+        this.gpt = gpt;
+        this.options = options;
+        this.allSrcFiles = allSrcFiles;
+        this.contextFiles = {};
+    }
+    generateCodePrompt(prompt, previousCode) {
+        const specialFileContents = (0, command_utils_1.collectSpecialFileContents)();
+        const specialFiles = Object.keys(specialFileContents).map((file) => `### Contents of ${file}\n\n${JSON.stringify(specialFileContents[file], null, 2)}\n\n`).join('\n');
+        const contextFileContents = Object.keys(this.contextFiles).map((file) => `### Contents of ${file}\n\n${this.contextFiles[file]}\n\n`).join('\n');
+        let promptText = `### Request
+
+Generate code that does the following: ${prompt}
+
+### Description of App
+
+${JSON.stringify((0, config_utils_1.getClovingConfig)(), null, 2)}
+
+${specialFiles}
+
+${contextFileContents}
+
+### Directory structure
+
+${this.allSrcFiles.join('\n')}
+
+`;
+        if (previousCode) {
+            promptText += `### Previously generated code
+
+${previousCode}
+
+`;
+        }
+        promptText += `### Example of a well-structured response
+
+Here are the files that I would like to generate:
+
+1. **src/commands/generate/shell.ts**
+
+\`\`\`typescript
+import inquirer from 'inquirer'
+import highlight from 'cli-highlight'
+import { execSync } from 'child_process'
+import ncp from 'copy-paste'
+import { extractMarkdown } from '../../utils/string_utils'
+import { getConfig } from '../../utils/config_utils'
+import ClovingGPT from '../../cloving_gpt'
+import type { ClovingGPTOptions } from '../../utils/types'
+
+const generateShellPrompt = (prompt: string | undefined): string => {
+  const shell = execSync('echo $SHELL').toString().trim()
+  const os = execSync('echo $OSTYPE').toString().trim()
+  return \`Generate an executable \${shell} script that works on \${os}. Try to make it a single line if possible and as simple and straightforward as possible.
+
+Do not add any commentary or context to the message other than the commit message itself.
+
+An example of the output for this should look like the following:
+\`\`\`
+
+### Request
+
+Generate code that does the following: ${prompt}
+
+Do not use any data from the example response structure, only use the structure. Generate the code and include filenames with paths to the code files mentioned and do not be lazy and ask me to keep the existing code or show things like previous code remains unchanged, always include existing code in the response.`;
+        return promptText;
+    }
+    displayGeneratedCode(rawCodeCommand) {
+        (0, string_utils_1.parseMarkdownInstructions)(rawCodeCommand).map(code => {
+            if (code.trim().startsWith('```')) {
+                const lines = code.split('\n');
+                const language = code.match(/```(\w+)/)?.[1] || 'plaintext';
+                console.log(lines[0]);
+                try {
+                    console.log((0, cli_highlight_1.default)(lines.slice(1, -1).join('\n'), { language }));
+                }
+                catch (error) {
+                    // don't highlight if it fails
+                    console.log(lines.slice(1, -1).join('\n'));
+                }
+                console.log(lines.slice(-1)[0]);
+            }
+            else {
+                console.log((0, cli_highlight_1.default)(code, { language: 'markdown' }));
+            }
+        });
+    }
+    async updateContextFiles(files, fileContents) {
+        for (const file of files) {
+            if (fileContents[file]) {
+                this.contextFiles[file] = fileContents[file];
+            }
+        }
+    }
+    async handleUserAction(rawCodeCommand, prompt) {
+        const [files, fileContents] = (0, string_utils_1.extractFilesAndContent)(rawCodeCommand);
+        if (this.options.save) {
+            await (0, string_utils_1.saveGeneratedFiles)(files, fileContents);
+            await this.updateContextFiles(files, fileContents);
+            return;
+        }
+        const action = await (0, prompts_1.select)({
+            message: 'What would you like to do?',
+            choices: [
+                { name: 'Revise', value: 'revise' },
+                { name: 'Explain', value: 'explain' },
+                { name: 'Save a Source Code File', value: 'save' },
+                { name: 'Save All Source Code Files', value: 'saveAll' },
+                { name: 'Copy Source Code to Clipboard', value: 'copySource' },
+                { name: 'Copy Entire Response to Clipboard', value: 'copyAll' },
+                { name: 'Done', value: 'done' },
+            ],
+        });
+        switch (action) {
+            case 'revise':
+                const newPrompt = await (0, prompts_1.input)({
+                    message: 'How would you like to modify the output:',
+                });
+                let includeMoreFiles = true;
+                while (includeMoreFiles) {
+                    const contextFile = await (0, prompts_1.input)({
+                        message: 'Enter the relative path of a file or directory you would like to include as context (or press enter to continue):',
+                    });
+                    if (contextFile) {
+                        this.contextFiles = await (0, command_utils_1.addFileOrDirectoryToContext)(contextFile, this.contextFiles, this.options);
+                    }
+                    else {
+                        includeMoreFiles = false;
+                    }
+                }
+                const newRawCodeCommand = await this.generateCode(newPrompt, rawCodeCommand);
+                this.displayGeneratedCode(newRawCodeCommand);
+                await this.handleUserAction(newRawCodeCommand, newPrompt);
+                break;
+            case 'explain':
+                const explainPrompt = this.generateExplainCodePrompt(rawCodeCommand);
+                const explainCodeCommand = await this.gpt.generateText({ prompt: explainPrompt });
+                console.log((0, cli_highlight_1.default)(explainCodeCommand, { language: 'markdown' }));
+                break;
+            case 'copySource':
+                let copyAnother = true;
+                while (copyAnother) {
+                    const fileToCopy = await (0, prompts_1.select)({
+                        message: 'Which file do you want to copy to the clipboard?',
+                        choices: files.map(file => ({ name: file, value: file })),
+                    });
+                    if (fileContents[fileToCopy]) {
+                        copy_paste_1.default.copy(fileContents[fileToCopy], () => {
+                            console.log(`${fileToCopy} copied to clipboard`);
+                        });
+                    }
+                    else {
+                        console.log('File content not found.');
+                    }
+                    const copyMore = await (0, prompts_1.confirm)({
+                        message: 'Do you want to copy another file?',
+                        default: true,
+                    });
+                    copyAnother = copyMore;
+                }
+                break;
+            case 'copyAll':
+                copy_paste_1.default.copy(rawCodeCommand, () => {
+                    console.log('Entire response copied to clipboard');
+                });
+                break;
+            case 'save':
+                let saveAnother = true;
+                while (saveAnother) {
+                    const fileToSave = await (0, prompts_1.select)({
+                        message: 'Which file do you want to save?',
+                        choices: files.map(file => ({ name: file, value: file })),
+                    });
+                    if (fileContents[fileToSave]) {
+                        const filePath = path_1.default.resolve(fileToSave);
+                        await fs_1.default.promises.mkdir(path_1.default.dirname(filePath), { recursive: true });
+                        await fs_1.default.promises.writeFile(filePath, fileContents[fileToSave]);
+                        console.log(`${fileToSave} has been saved.`);
+                        await this.updateContextFiles([fileToSave], fileContents);
+                    }
+                    else {
+                        console.log('File content not found.');
+                    }
+                    const saveMore = await (0, prompts_1.confirm)({
+                        message: 'Do you want to save another file?',
+                        default: true,
+                    });
+                    saveAnother = saveMore;
+                }
+                break;
+            case 'saveAll':
+                await (0, string_utils_1.saveGeneratedFiles)(files, fileContents);
+                await this.updateContextFiles(files, fileContents);
+                console.log('All files have been saved.');
+                break;
+            case 'done':
+                break;
+        }
+    }
+    generateExplainCodePrompt(prompt) {
+        return `${prompt}
+
+## Task
+
+Please briefly explain how the code works in this.`;
+    }
+    async generateCode(prompt, previousCode) {
+        const codePrompt = this.generateCodePrompt(prompt, previousCode);
+        return await this.gpt.generateText({ prompt: codePrompt });
+    }
+    async processCode(prompt) {
+        try {
+            if (this.options.files) {
+                let expandedFiles = [];
+                for (const file of this.options.files) {
+                    const filePath = path_1.default.resolve(file);
+                    if (await fs_1.default.promises.stat(filePath).then(stat => stat.isDirectory()).catch(() => false)) {
+                        const dirFiles = await (0, command_utils_1.getAllFilesInDirectory)(filePath);
+                        expandedFiles = expandedFiles.concat(dirFiles.map(f => path_1.default.relative(process.cwd(), f)));
+                    }
+                    else {
+                        expandedFiles.push(path_1.default.relative(process.cwd(), filePath));
+                    }
+                }
+                this.options.files = expandedFiles;
+                for (const file of this.options.files) {
+                    const filePath = path_1.default.resolve(file);
+                    if (await fs_1.default.promises.stat(filePath).then(stat => stat.isFile()).catch(() => false)) {
+                        const content = await fs_1.default.promises.readFile(filePath, 'utf-8');
+                        this.contextFiles[file] = content;
+                    }
+                }
+            }
+            else {
+                let includeMoreFiles = true;
+                while (includeMoreFiles) {
+                    const contextFile = await (0, prompts_1.input)({
+                        message: `Enter the relative path of a file or directory you would like to include as context (or press enter to continue):`,
+                    });
+                    if (contextFile) {
+                        this.contextFiles = await (0, command_utils_1.addFileOrDirectoryToContext)(contextFile, this.contextFiles, this.options);
+                    }
+                    else {
+                        includeMoreFiles = false;
+                    }
+                }
+            }
+            if (!prompt) {
+                const userPrompt = await (0, prompts_1.input)({
+                    message: 'What would you like the code to do:',
+                });
+                prompt = userPrompt;
+            }
+            let rawCodeCommand = await this.generateCode(prompt);
+            this.displayGeneratedCode(rawCodeCommand);
+            if (this.options.save) {
+                const [files, fileContents] = (0, string_utils_1.extractFilesAndContent)(rawCodeCommand);
+                await (0, string_utils_1.saveGeneratedFiles)(files, fileContents);
+                await this.updateContextFiles(files, fileContents);
+            }
+            else {
+                await this.handleUserAction(rawCodeCommand, prompt);
+            }
+            if (this.options.interactive) {
+                let continueInteractive = true;
+                while (continueInteractive) {
+                    const newPrompt = await (0, prompts_1.input)({
+                        message: 'Revise the code (or press enter to finish):',
+                    });
+                    if (newPrompt.trim() === '') {
+                        continueInteractive = false;
+                    }
+                    else {
+                        let includeMoreFiles = true;
+                        while (includeMoreFiles) {
+                            const contextFile = await (0, prompts_1.input)({
+                                message: 'Enter the relative path of a file or directory you would like to include as context (or press enter to continue):',
+                            });
+                            if (contextFile) {
+                                this.contextFiles = await (0, command_utils_1.addFileOrDirectoryToContext)(contextFile, this.contextFiles, this.options);
+                            }
+                            else {
+                                includeMoreFiles = false;
+                            }
+                        }
+                        rawCodeCommand = await this.generateCode(newPrompt, rawCodeCommand);
+                        this.displayGeneratedCode(rawCodeCommand);
+                        if (this.options.save || this.options.interactive) {
+                            const [files, fileContents] = (0, string_utils_1.extractFilesAndContent)(rawCodeCommand);
+                            await (0, string_utils_1.saveGeneratedFiles)(files, fileContents);
+                            await this.updateContextFiles(files, fileContents);
+                        }
+                        else {
+                            await this.handleUserAction(rawCodeCommand, newPrompt);
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error('Could not generate code', error);
+        }
+    }
+}
+exports.default = CodeManager;