aico-ai 1.0.0

package/.aicoignore

@@ -0,0 +1,18 @@
+# CodeGuard AI Ignore
+
+# Dependencies
+node_modules/
+package-lock.json
+yarn.lock
+pnpm-lock.yaml
+
+# Build outputs
+dist/
+build/
+
+# Secrets
+.env
+.env.*
+
+# Large files
+*.log

package/.env.example

@@ -0,0 +1 @@
+GROQ_API_KEY=your_groq_api_key_here

package/README.md

@@ -0,0 +1,68 @@
+# Aico 🚀
+
+**Aico** is an intelligent CLI tool that acts as a gatekeeper for your code. It uses AI (powered by Groq) to review your changes before you push them, ensuring high quality, security, and consistency across your projects.
+
+## Features
+
+- 🔍 **AI Code Review**: Semantic analysis of your git diffs to catch bugs, security issues, and code smells.
+- ✨ **Apply Fixes**: Automatically apply suggested improvements with a single click.
+- 📝 **AI Commit Messages**: Generate high-quality, Conventional Commit messages based on your changes.
+- 🛡️ **Git Hook Integration**: Seamlessly integrates with Husky to run reviews as a `pre-push` hook.
+- 🤫 **Silent Mode**: Run reviews without blocking your workflow.
+- 🌍 **Global Config**: Configure your API key once and use it across all your projects.
+
+## Installation
+
+```bash
+npm install -g aico-gatekeeper
+# or
+npm install --save-dev aico-gatekeeper
+```
+
+## Getting Started
+
+1. **Initialize Aico**:
+   Run the following command to set up your API key (Groq) and optionally configure Git hooks.
+   ```bash
+   aico init
+   ```
+
+2. **Review your changes**:
+   Manually review your staged changes:
+   ```bash
+   aico review
+   ```
+
+3. **Commit with AI**:
+   Let Aico write your commit message:
+   ```bash
+   aico commit
+   ```
+
+## Usage
+
+### Commands
+
+- `aico init`: Setup API keys and Git hooks.
+- `aico review`: Analyze staged changes and suggest improvements.
+- `aico commit`: Generate and apply an AI-suggested commit message.
+
+### Options
+
+- `--silent`, `-s`: Run the review in silent mode (doesn't block the push).
+
+## Configuration
+
+Aico stores its global configuration in `~/.aicorc`. You can also use environment variables:
+
+```bash
+GROQ_API_KEY=your_key_here
+```
+
+## Why Aico?
+
+While IDE extensions like Copilot or Cursor are great assistants, **Aico** is your project's **Gatekeeper**. It ensures that no matter what IDE your team uses, every piece of code meets the same quality standards before it reaches the remote repository.
+
+## License
+
+ISC

package/index.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+import { getStagedDiff, applyFix } from './lib/git-utils.js';
+import { reviewCode, generateCommitMessage } from './lib/ai-service.js';
+import { parseAIResponse, displayIssues } from './lib/reviewer.js';
+import pc from 'picocolors';
+import enquirer from 'enquirer';
+import fs from 'fs';
+const { prompt } = enquirer;
+
+import { saveGlobalConfig } from './lib/config-utils.js';
+import { execSync } from 'child_process';
+
+async function init() {
+    console.log(pc.bold(pc.blue('Aico: Initializing...')));
+
+    const { apiKey } = await prompt({
+        type: 'input',
+        name: 'apiKey',
+        message: 'Enter your Groq API Key:'
+    });
+
+    if (apiKey) {
+        saveGlobalConfig({ GROQ_API_KEY: apiKey });
+        console.log(pc.green('API Key saved globally in ~/.aicorc'));
+    }
+
+    const { setupHusky } = await prompt({
+        type: 'confirm',
+        name: 'setupHusky',
+        message: 'Would you like to setup Aico as a pre-push git hook?',
+        initial: true
+    });
+
+    if (setupHusky) {
+        try {
+            console.log(pc.blue('Setting up Husky...'));
+            execSync('npx husky init', { stdio: 'inherit' });
+            // Add aico to pre-push
+            const huskyPath = '.husky/pre-push';
+            const hookContent = '#!/bin/sh\nnpx aico review\n';
+            fs.writeFileSync(huskyPath, hookContent, { mode: 0o755 });
+            console.log(pc.green('Husky pre-push hook configured!'));
+        } catch (e) {
+            console.error(pc.red('Failed to setup Husky:'), e.message);
+        }
+    }
+}
+
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0] || 'review';
+    const isSilent = args.includes('--silent') || args.includes('-s');
+
+    if (command === 'init') {
+        await init();
+        return;
+    }
+
+    if (command === 'commit') {
+        console.log(pc.bold(pc.blue('Aico: Generating commit message...')));
+        try {
+            const diff = await getStagedDiff();
+            if (!diff || diff.trim() === '') {
+                console.log(pc.yellow('No staged changes found to commit.'));
+                return;
+            }
+
+            let message = await generateCommitMessage(diff);
+
+            while (true) {
+                console.log(`\n${pc.bold('Suggested message:')} ${pc.green(message)}`);
+
+                const { action } = await prompt({
+                    type: 'select',
+                    name: 'action',
+                    message: 'What would you like to do?',
+                    choices: [
+                        { name: 'accept', message: 'Accept and commit', value: 'accept' },
+                        { name: 'edit', message: 'Edit message', value: 'edit' },
+                        { name: 'regenerate', message: 'Regenerate', value: 'regenerate' },
+                        { name: 'abort', message: 'Abort', value: 'abort' }
+                    ]
+                });
+
+                if (action === 'accept') {
+                    execSync(`git commit -m "${message.replace(/"/g, '\\"')}"`, { stdio: 'inherit' });
+                    console.log(pc.green('Committed successfully!'));
+                    return;
+                } else if (action === 'edit') {
+                    const { newMessage } = await prompt({
+                        type: 'input',
+                        name: 'newMessage',
+                        message: 'Edit commit message:',
+                        initial: message
+                    });
+                    message = newMessage;
+                } else if (action === 'regenerate') {
+                    console.log(pc.blue('Regenerating...'));
+                    message = await generateCommitMessage(diff);
+                } else {
+                    console.log(pc.red('Commit aborted.'));
+                    return;
+                }
+            }
+        } catch (error) {
+            console.error(pc.red('Error during commit:'), error.message);
+            process.exit(1);
+        }
+    }
+
+    console.log(pc.bold(pc.blue('Aico: Analyzing your changes...')));
+
+    try {
+        const diff = await getStagedDiff();
+
+        if (!diff || diff.trim() === '') {
+            console.log(pc.yellow('No staged changes found to review.'));
+            return;
+        }
+
+        const aiResponse = await reviewCode(diff);
+        const issues = parseAIResponse(aiResponse);
+
+        if (issues.length === 0) {
+            console.log(pc.green('No issues found. Good job!'));
+        } else {
+            displayIssues(issues);
+
+            for (const issue of issues) {
+                console.log(pc.cyan(`\nReviewing issue in ${pc.bold(issue.file)}...`));
+                console.log(`${pc.yellow('Issue:')} ${issue.issue}`);
+
+                const choices = [
+                    { name: 'skip', message: 'Skip this issue', value: 'skip' },
+                ];
+
+                if (issue.correctedCode) {
+                    choices.unshift({ name: 'apply', message: 'Apply suggested fix', value: 'apply' });
+                }
+
+                const { action } = await prompt({
+                    type: 'select',
+                    name: 'action',
+                    message: 'What would you like to do?',
+                    choices: [...choices, { name: 'abort', message: 'Abort push', value: 'abort' }]
+                });
+
+                if (action === 'apply') {
+                    const success = await applyFix(issue.file, issue.correctedCode);
+                    if (success) {
+                        console.log(pc.green(`Applied fix to ${issue.file}`));
+                    }
+                } else if (action === 'abort') {
+                    if (isSilent) {
+                        console.log(pc.yellow('Warning: Review aborted with issues, but proceeding anyway (Silent Mode).'));
+                        break;
+                    }
+                    console.log(pc.red('Push aborted.'));
+                    process.exit(1);
+                }
+            }
+        }
+
+        if (!isSilent) {
+            const finalAction = await prompt({
+                type: 'confirm',
+                name: 'proceed',
+                message: 'Would you like to proceed with the push?',
+                initial: true
+            });
+
+            if (!finalAction.proceed) {
+                console.log(pc.red('Push aborted.'));
+                process.exit(1);
+            }
+        } else if (issues.length > 0) {
+            console.log(pc.yellow('\nReview completed with issues, but proceeding anyway (Silent Mode).'));
+        }
+
+        console.log(pc.green('Proceeding with push...'));
+    } catch (error) {
+        console.error(pc.red('Error during review:'), error.message);
+        process.exit(1);
+    }
+}
+
+main();

package/lib/ai-service.js

@@ -0,0 +1,99 @@
+import Groq from 'groq-sdk';
+import dotenv from 'dotenv';
+
+import { getApiKey } from './config-utils.js';
+
+dotenv.config();
+
+const groq = new Groq({
+    apiKey: getApiKey(),
+});
+
+/**
+ * Sends code diff to Groq for review.
+ * @param {string} diff 
+ * @returns {Promise<string>} AI review response.
+ */
+export async function reviewCode(diff) {
+    const apiKey = getApiKey();
+    if (!apiKey) {
+        throw new Error('GROQ_API_KEY is not set. Run "aico init" to configure it.');
+    }
+
+    if (!diff || diff.trim() === '') {
+        return 'No changes detected to review.';
+    }
+
+    const systemPrompt = `
+You are an expert code reviewer. Analyze the following git diff and provide constructive feedback.
+Focus on:
+1. Security vulnerabilities.
+2. Performance bottlenecks.
+3. Code readability and clean code principles.
+4. Potential bugs.
+
+Format your response as a list of issues. For each issue, provide:
+- File: [filename]
+- Issue: [description]
+- Suggestion: [how to fix it]
+- CorrectedCode: [the FULL corrected content of the file, wrapped in triple backticks]
+
+Keep it concise and professional. Do not use emojis.
+`;
+
+    try {
+        const chatCompletion = await groq.chat.completions.create({
+            messages: [
+                { role: 'system', content: systemPrompt },
+                { role: 'user', content: `Review this diff:\n\n${diff}` },
+            ],
+            model: 'llama-3.3-70b-versatile',
+        });
+
+        return chatCompletion.choices[0]?.message?.content || 'No feedback provided.';
+    } catch (error) {
+        console.error('Error during AI review:', error);
+        throw error;
+    }
+}
+
+/**
+ * Generates a commit message based on the diff.
+ * @param {string} diff 
+ * @returns {Promise<string>} Suggested commit message.
+ */
+export async function generateCommitMessage(diff) {
+    const apiKey = getApiKey();
+    if (!apiKey) {
+        throw new Error('GROQ_API_KEY is not set. Run "aico init" to configure it.');
+    }
+
+    if (!diff || diff.trim() === '') {
+        return 'chore: update files';
+    }
+
+    const systemPrompt = `
+You are an expert at writing git commit messages following the Conventional Commits specification.
+Analyze the diff and provide a single, concise commit message.
+Format: <type>(<scope>): <description>
+Types: feat, fix, docs, style, refactor, test, chore.
+Description: Imperative, present tense, no period at the end.
+
+Do not include any other text, only the commit message itself. Do not use emojis.
+`;
+
+    try {
+        const chatCompletion = await groq.chat.completions.create({
+            messages: [
+                { role: 'system', content: systemPrompt },
+                { role: 'user', content: `Generate a commit message for this diff:\n\n${diff}` },
+            ],
+            model: 'llama-3.3-70b-versatile',
+        });
+
+        return chatCompletion.choices[0]?.message?.content?.trim() || 'chore: update files';
+    } catch (error) {
+        console.error('Error generating commit message:', error);
+        throw error;
+    }
+}

package/lib/config-utils.js

@@ -0,0 +1,40 @@
+import os from 'os';
+import fs from 'fs';
+import path from 'path';
+
+const CONFIG_PATH = path.join(os.homedir(), '.aicorc');
+
+/**
+ * Saves the API key to a global config file in the user's home directory.
+ * @param {string} apiKey 
+ */
+export function saveGlobalConfig(config) {
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+
+/**
+ * Loads the global config.
+ * @returns {object|null}
+ */
+export function loadGlobalConfig() {
+    if (fs.existsSync(CONFIG_PATH)) {
+        try {
+            return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+        } catch (e) {
+            return null;
+        }
+    }
+    return null;
+}
+
+/**
+ * Gets the API key from environment variables or global config.
+ * @returns {string|null}
+ */
+export function getApiKey() {
+    // Priority: Process Env > Local .env (handled by dotenv) > Global Config
+    if (process.env.GROQ_API_KEY) return process.env.GROQ_API_KEY;
+
+    const globalConfig = loadGlobalConfig();
+    return globalConfig?.GROQ_API_KEY || null;
+}

package/lib/git-utils.js

@@ -0,0 +1,56 @@
+import { simpleGit } from 'simple-git';
+
+const git = simpleGit();
+
+/**
+ * Gets the diff of staged changes.
+ * @returns {Promise<string>} The git diff string.
+ */
+export async function getStagedDiff() {
+    try {
+        return await git.diff(['--cached']);
+    } catch (error) {
+        console.error('Error getting staged diff:', error);
+        return '';
+    }
+}
+
+/**
+ * Gets the diff between current branch and its upstream.
+ * Useful for pre-push hook.
+ * @returns {Promise<string>} The git diff string.
+ */
+export async function getPushDiff() {
+    try {
+        // This gets the diff between the current branch and its remote tracking branch
+        return await git.diff(['@{u}..HEAD']);
+    } catch (error) {
+        // If no upstream is set, we might want to compare with a default branch or just return staged
+        console.warn('No upstream branch found. Falling back to staged changes.');
+        return await getStagedDiff();
+    }
+}
+
+import fs from 'fs';
+
+/**
+ * Applies a suggested fix to a file.
+ * @param {string} filePath 
+ * @param {string} correctedCode 
+ */
+export async function applyFix(filePath, correctedCode) {
+    try {
+        // For now, we assume the AI provides the corrected version of the code it analyzed.
+        // A more advanced version would use diffing/patching.
+        // If the AI provides a snippet, we'd need to find and replace.
+        // For this MVP, we'll just log that we are applying it.
+
+        // Let's try a simple approach: if the file exists, we write the code.
+        // WARNING: This is a simple overwrite for now.
+        fs.writeFileSync(filePath, correctedCode);
+        return true;
+    } catch (error) {
+        console.error(`Error applying fix to ${filePath}:`, error);
+        return false;
+    }
+}

package/lib/reviewer.js

@@ -0,0 +1,51 @@
+import pc from 'picocolors';
+
+/**
+ * Parses the AI response into a structured format.
+ * @param {string} response 
+ * @returns {Array<{file: string, issue: string, suggestion: string}>}
+ */
+export function parseAIResponse(response) {
+    const issues = [];
+    const blocks = response.split(/File: /i).filter(block => block.trim() !== '');
+
+    for (const block of blocks) {
+        const lines = block.split('\n');
+        const file = lines[0]?.trim();
+        const issueMatch = block.match(/Issue: (.*)/i);
+        const suggestionMatch = block.match(/Suggestion: (.*)/i);
+        const codeMatch = block.match(/CorrectedCode:[\s\S]*?```[\w]*\n([\s\S]*?)```/i);
+
+        if (file && issueMatch && suggestionMatch) {
+            issues.push({
+                file,
+                issue: issueMatch[1].trim(),
+                suggestion: suggestionMatch[1].trim(),
+                correctedCode: codeMatch ? codeMatch[1].trim() : null,
+            });
+        }
+    }
+
+    return issues;
+}
+
+/**
+ * Displays the issues to the user in a formatted way.
+ * @param {Array<{file: string, issue: string, suggestion: string}>} issues 
+ */
+export function displayIssues(issues) {
+    if (issues.length === 0) {
+        console.log(pc.green('No issues found. Good job!'));
+        return;
+    }
+
+    console.log(pc.yellow(`Found ${issues.length} potential issues:\n`));
+
+    issues.forEach((issue, index) => {
+        console.log(pc.cyan(`--------------------------------------------------`));
+        console.log(`${pc.bold('File:')} ${issue.file}`);
+        console.log(`${pc.bold('Issue:')} ${issue.issue}`);
+        console.log(`${pc.bold('Suggestion:')} ${issue.suggestion}`);
+    });
+    console.log(pc.cyan(`--------------------------------------------------\n`));
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "aico-ai",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "aico": "./index.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "description": "AI-powered git gatekeeper for code reviews and commit message generation.",
+  "keywords": [
+    "ai",
+    "git",
+    "code-review",
+    "commit",
+    "groq",
+    "cli",
+    "developer-tools"
+  ],
+  "author": "Lucas Silva from CodeTech Software <projetos@codetechsoftware.com.br>",
+  "license": "ISC",
+  "dependencies": {
+    "dotenv": "^17.2.3",
+    "enquirer": "^2.4.1",
+    "groq-sdk": "^0.37.0",
+    "husky": "^9.1.7",
+    "picocolors": "^1.1.1",
+    "simple-git": "^3.30.0"
+  }
+}