husky-ai 1.0.0

package/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

package/README.md

@@ -0,0 +1,61 @@
+# 🐶 Husky AI
+
+**Zero-config AI Code Reviewer for your git commits.**
+
+Husky AI automatically reviews your staged changes before you commit, catching bugs, security issues, and sloppy code using your favorite local AI engine (OpenCode, Claude, etc.).
+
+![License](https://img.shields.io/npm/l/husky-ai)
+![Version](https://img.shields.io/npm/v/husky-ai)
+
+## ✨ Features
+
+- **Zero Config**: Auto-detects your installed AI tools.
+- **Detailed Reviews**: "GitHub-style" comments with code snippets and line numbers.
+- **Smart Gatekeeping**: Blocks commits with critical bugs or security risks, but allows suggestions.
+- **Privacy First**: Runs locally using your existing CLI tools. Your code goes only where your AI tool sends it.
+
+## 🚀 Quick Start
+
+### 1. Install & Init
+Run this in your project root (we automatically install `husky` if you don't have it):
+
+```bash
+npx husky-ai init
+```
+
+Follow the prompts to select your AI engine (e.g., OpenCode).
+
+### 2. Commit
+Just commit as usual!
+
+```bash
+git add .
+git commit -m "feat: my new feature"
+```
+
+Husky AI will intercept the commit, review the changes, and approve or reject it.
+
+## ⚙️ Configuration
+
+Your configuration is stored in `package.json`:
+
+```json
+{
+  "huskyAi": {
+    "engine": "opencode"
+  }
+}
+```
+
+Supported engines:
+- `opencode` (Recommended)
+- `claude` (Coming soon)
+- `codex` (Coming soon)
+
+## 🤝 Contributing
+
+Pull requests are welcome!
+
+## 📄 License
+
+MIT

package/bin/husky-ai.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/index.js';

package/dist/commands/init.js

@@ -0,0 +1,95 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import execa from 'execa';
+import ora from 'ora';
+import fs from 'fs';
+import path from 'path';
+import { setConfig, getPackageJson } from '../utils/config.js';
+async function checkCommand(cmd) {
+    try {
+        await execa.command(`command -v ${cmd}`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function initCommand() {
+    console.log(chalk.bold.cyan('\n🐶 Husky AI Setup\n'));
+    // 1. Detect Engines
+    const spinner = ora('Detecting AI engines...').start();
+    const hasOpenCode = await checkCommand('opencode');
+    const hasClaude = await checkCommand('claude');
+    const hasCodex = await checkCommand('codex');
+    spinner.stop();
+    const choices = [];
+    if (hasOpenCode)
+        choices.push({ name: 'OpenCode (Recommended)', value: 'opencode' });
+    if (hasClaude)
+        choices.push({ name: 'Claude Code', value: 'claude' });
+    if (hasCodex)
+        choices.push({ name: 'OpenAI Codex', value: 'codex' });
+    choices.push(new inquirer.Separator());
+    choices.push({ name: 'Install OpenCode', value: 'install-opencode' });
+    // 2. Select Engine
+    const { engine } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'engine',
+            message: 'Which AI engine do you want to use?',
+            choices: choices,
+        },
+    ]);
+    // Handle Installation
+    if (engine === 'install-opencode') {
+        console.log(chalk.yellow('\nPlease install OpenCode manually: https://opencode.dev'));
+        return;
+    }
+    // 3. Verify Auth (Stub for now)
+    // TODO: Add actual auth check command here
+    // 4. Install Husky
+    const pkg = getPackageJson();
+    const hasHusky = pkg?.devDependencies?.husky || pkg?.dependencies?.husky;
+    if (!hasHusky) {
+        const installSpinner = ora('Installing Husky...').start();
+        try {
+            await execa('npm', ['install', 'husky', '--save-dev']);
+            await execa('npx', ['husky', 'init']);
+            installSpinner.succeed('Husky installed');
+        }
+        catch (e) {
+            installSpinner.fail('Failed to install Husky');
+            console.error(e.message);
+            return;
+        }
+    }
+    // 5. Create Hook
+    const hookPath = path.join(process.cwd(), '.husky', 'pre-commit');
+    const hookCmd = 'npx husky-ai review';
+    try {
+        // Ensure directory exists
+        if (!fs.existsSync(path.dirname(hookPath))) {
+            await execa('npx', ['husky', 'init']);
+        }
+        // Read existing hook
+        let currentHook = '';
+        if (fs.existsSync(hookPath)) {
+            currentHook = fs.readFileSync(hookPath, 'utf-8');
+        }
+        if (!currentHook.includes('husky-ai review')) {
+            fs.appendFileSync(hookPath, `\n# Run AI Code Review\n${hookCmd}\n`);
+            console.log(chalk.green('✅ Added pre-commit hook'));
+        }
+        else {
+            console.log(chalk.gray('ℹ️  Pre-commit hook already exists'));
+        }
+        // Make executable
+        await execa('chmod', ['+x', hookPath]);
+    }
+    catch (e) {
+        console.error(chalk.red('Failed to setup hook:'), e.message);
+    }
+    // 6. Save Config
+    setConfig({ engine });
+    console.log(chalk.green(`\n🎉 Setup complete! Using ${engine}.\n`));
+}

package/dist/commands/review.js

@@ -0,0 +1,97 @@
+import execa from 'execa';
+import chalk from 'chalk';
+import { getConfig } from '../utils/config.js';
+import { renderReview } from '../utils/renderer.js';
+const PROMPT_TEMPLATE = (diff) => `
+I have saved the staged changes below.
+Act as a senior software engineer doing a code review.
+Analyze the changes for:
+- Critical bugs (logic errors, crashes)
+- Security vulnerabilities
+- Best practices & Clean code
+- Performance issues
+
+Output your review strictly in this JSON format (no markdown code blocks, just raw JSON if possible, or inside a JSON block):
+
+{
+  "summary": "Brief bulleted summary of changes",
+  "comments": [
+    {
+      "file": "path/to/file",
+      "line_snippet": "quoted code line (or empty)",
+      "line_number": number (approximate line number of the issue),
+      "type": "issue" | "suggestion" | "praise",
+      "message": "Explanation of the finding",
+      "critical": boolean
+    }
+  ],
+  "verdict": "PASS" | "FAIL"
+}
+
+Rules:
+- Mark 'critical': true ONLY for bugs, security risks, or breaking changes.
+- Use type 'suggestion' for refactoring/style.
+- Use type 'praise' for particularly good code.
+- If everything is good, return verdict PASS and empty/praise comments.
+
+CHANGES:
+${diff}
+`;
+export async function reviewCommand() {
+    const config = getConfig();
+    // Default to opencode if not configured (or prompt user?)
+    const engine = config?.engine || 'opencode';
+    // 1. Get Diff
+    try {
+        const { stdout: diff } = await execa('git', ['diff', '--cached']);
+        if (!diff.trim()) {
+            // No changes
+            process.exit(0);
+        }
+        console.log(chalk.cyan('🤖 AI Agent is reviewing your changes...'));
+        let jsonResponse;
+        // 2. Call Engine
+        if (engine === 'opencode') {
+            // We use the 'run' command and pipe stdin or pass argument
+            // Ideally we use a temporary file for large diffs to avoid arg length limits
+            const prompt = PROMPT_TEMPLATE(diff);
+            // Limit diff size?
+            if (diff.length > 50000) {
+                console.warn(chalk.yellow('⚠️  Diff is too large, truncating...'));
+            }
+            // console.log("Sending prompt to OpenCode...");
+            const { stdout } = await execa('opencode', ['run', prompt], {
+                input: '',
+                env: { ...process.env, CI: 'true', NO_COLOR: 'true' }
+            });
+            // console.log("Got response length:", stdout.length);
+            jsonResponse = stdout;
+        }
+        else {
+            console.error(chalk.red(`Engine ${engine} not yet implemented`));
+            process.exit(1);
+        }
+        // 3. Parse JSON
+        let review;
+        try {
+            // Clean up markdown code blocks if present
+            const cleanJson = jsonResponse.replace(/```json\n|\n```/g, '').trim();
+            // Find JSON object
+            const match = cleanJson.match(/\{[\s\S]*\}/);
+            if (!match)
+                throw new Error('No JSON found');
+            review = JSON.parse(match[0]);
+        }
+        catch (e) {
+            console.log(chalk.yellow('⚠️  Could not parse AI response. Raw output:'));
+            console.log(jsonResponse);
+            process.exit(0); // Fail open?
+        }
+        // 4. Render
+        renderReview(review);
+    }
+    catch (e) {
+        console.error(chalk.red('Error running review:'), e.message);
+        process.exit(1);
+    }
+}

package/dist/index.js

@@ -0,0 +1,17 @@
+import { Command } from 'commander';
+import { initCommand } from './commands/init.js';
+import { reviewCommand } from './commands/review.js';
+const program = new Command();
+program
+    .name('husky-ai')
+    .description('Zero-config AI code review hook for Git')
+    .version('1.0.0');
+program
+    .command('init')
+    .description('Initialize husky-ai in the current project')
+    .action(initCommand);
+program
+    .command('review')
+    .description('Run AI code review on staged files')
+    .action(reviewCommand);
+program.parse(process.argv);

package/dist/utils/config.js

@@ -0,0 +1,22 @@
+import fs from 'fs';
+import path from 'path';
+const PKG_PATH = path.join(process.cwd(), 'package.json');
+export function getConfig() {
+    if (!fs.existsSync(PKG_PATH))
+        return null;
+    const pkg = JSON.parse(fs.readFileSync(PKG_PATH, 'utf-8'));
+    return pkg.huskyAi || null;
+}
+export function setConfig(config) {
+    if (!fs.existsSync(PKG_PATH)) {
+        throw new Error('package.json not found in current directory');
+    }
+    const pkg = JSON.parse(fs.readFileSync(PKG_PATH, 'utf-8'));
+    pkg.huskyAi = config;
+    fs.writeFileSync(PKG_PATH, JSON.stringify(pkg, null, 2));
+}
+export function getPackageJson() {
+    if (!fs.existsSync(PKG_PATH))
+        return null;
+    return JSON.parse(fs.readFileSync(PKG_PATH, 'utf-8'));
+}

package/dist/utils/renderer.js

@@ -0,0 +1,48 @@
+import chalk from 'chalk';
+export function renderReview(review) {
+    console.log('\n' + chalk.bold.cyan('🤖 AI Code Review'));
+    console.log(chalk.gray('──────────────────────────────────────────────────'));
+    // Summary
+    if (review.summary) {
+        console.log('\n' + chalk.bold('📝 Summary:'));
+        review.summary.split('\n').forEach(line => {
+            console.log(`  ${line.replace(/^- /, '• ')}`);
+        });
+    }
+    // Group comments
+    const commentsByFile = {};
+    review.comments.forEach(c => {
+        if (!commentsByFile[c.file])
+            commentsByFile[c.file] = [];
+        commentsByFile[c.file].push(c);
+    });
+    let hasCritical = false;
+    Object.keys(commentsByFile).forEach(file => {
+        console.log('\n' + chalk.bold.blue(`📄 ${file}`));
+        commentsByFile[file].forEach(comment => {
+            const isCritical = comment.critical || comment.type === 'issue';
+            if (isCritical)
+                hasCritical = true;
+            const icon = isCritical ? '❌' : (comment.type === 'suggestion' ? '💡' : '✅');
+            const colorFn = isCritical ? chalk.red : (comment.type === 'suggestion' ? chalk.yellow : chalk.green);
+            const loc = comment.line_number ? `:${comment.line_number}` : '';
+            console.log(`  ${icon} ${colorFn(chalk.bold(comment.type.toUpperCase()))} ${chalk.gray(`(at line ${comment.line_number || '?'})`)}: ${comment.message}`);
+            if (comment.line_snippet) {
+                console.log(`    ${chalk.gray(`┌──${file}${loc}`)}`);
+                console.log(`    ${chalk.gray('│')}  ${comment.line_snippet.trim()}`);
+                console.log(`    ${chalk.gray('└──')}`);
+            }
+        });
+    });
+    console.log(chalk.gray('\n──────────────────────────────────────────────────'));
+    if (review.verdict === 'FAIL' || hasCritical) {
+        console.log(chalk.bgRed.bold(' ⛔ COMMIT REJECTED ') + chalk.red(' Critical issues found.\n'));
+        process.exit(1);
+    }
+    else {
+        const hasSuggestions = review.comments.some(c => c.type === 'suggestion');
+        const warning = hasSuggestions ? chalk.yellow('(with suggestions)') : chalk.green('(clean)');
+        console.log(chalk.green.bold(' ✅ COMMIT ACCEPTED ') + warning + '\n');
+        process.exit(0);
+    }
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "husky-ai",
+  "version": "1.0.0",
+  "description": "Zero-config AI code review hook for git commits",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "husky-ai": "./bin/husky-ai.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc",
+    "prepare": "npm run build"
+  },
+  "keywords": [
+    "git",
+    "hook",
+    "husky",
+    "ai",
+    "code-review",
+    "opencode",
+    "claude"
+  ],
+  "author": "Saurav",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/saurav/husky-ai.git"
+  },
+  "devDependencies": {
+    "@types/chalk": "^2.2.4",
+    "@types/inquirer": "^9.0.9",
+    "@types/node": "^25.0.9",
+    "boxen": "^5.1.2",
+    "chalk": "^4.1.2",
+    "commander": "^14.0.2",
+    "execa": "^5.1.1",
+    "inquirer": "^9.2.12",
+    "ora": "^5.4.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3",
+    "zod": "^4.3.5"
+  }
+}