gennady 0.3.0 → 0.5.0

package/README.md

@@ -3,9 +3,100 @@
 **GEN**erate **N**ext-level **A**utomated **D**escription **Y**ntelligence.
 
 ```bash
+# Commit message
 npx gennady
+
+# Code review for critical issues
+npx gennady review
+
+# Quickly display the contents
+npx gennady cat <path1> <path2> ...
+```
+
+---
+
+### ✨ Features
+
+- 🤖 [**Commit Message**](#-commit-messages): Automatically generate clear, descriptive git commit messages from your staged changes.
+- 📝 [**review**](#-review): Instantly review your staged git changes for critical issues (logic, runtime, security).
+- 🐱 [**cat**](#-cat): Quickly display the contents of multiple files or directories at once, filtered by allowed extensions (default: .js, .ts, .tsx).
+
+---
+
+## 🔖 Usage Overview
+
+Gennady provides several main CLI commands:
+- `npx gennady` — Generate commit messages from your staged git changes.
+- `npx gennady cat <path1> <path2> ...` — Display the contents of one or more files or directories, filtered by allowed extensions.
+- `npx gennady review` — Review your staged git changes for critical issues.
+
+---
+
+## 🤖 Commit Messages
+
+```sh
+# Basic usage
+npx gennady
+
+# Generate oneline commit message
+npx gennady --mode=oneline
+
+# Generate detailed commit message
+npx gennady --mode=detailed
+
+# Generate detailed commit message relative to the target branch
+npx gennady --branch=develop
+```
+
+### Options
+| Option            | Alias(es)        | Description                                  |
+|-------------------|------------------|----------------------------------------------|
+| `--mode`          | `-m`             | Set the mode (`auto`, `oneline`, `detailed`) |
+| `--oneline`       | `--short`, `-o`  | Generate a one-line commit message           |
+| `--model`         |                  | Specify the AI model                         |
+| `--branch`        | `-b`             | Target branch for diff                       |
+| `--apply`         |                  | Immediately apply the generated commit message to git |
+
+
+#### What Happens?
+- Gennady analyzes your staged changes.
+- It generates a commit message.
+- If your system language isn't English, it translates the message for you.
+
+---
+
+
+## 📝 review
+
+Review your staged git changes for critical issues.
+
+```sh
+npx gennady review
+
+# Review changes relative to a specific branch
+npx gennady review --branch=develop
+```
+
+#### What Happens?
+- Gennady analyzes your staged changes.
+- It checks only the lines added or modified in your diff for critical issues (logic, runtime, and security errors).
+- If no critical issues are found, it outputs `GOOD`.
+- If issues are found, they are listed in a clear, structured format.
+
+---
+
+## 🐱 cat
+
+Display the contents of files or directories (with filtering for allowed extensions).
+
+```sh
+npx gennady cat ./src/
 ```
 
+#### Output
+- Shows file contents with headers per file.
+- Hints for copying output without color codes.
+
 ---
 
 ## Setup LLM
@@ -22,32 +113,20 @@ ollama serve
 
 ### External
 
-Create `~/.gennadyrc` file:
+Create `~/.gennadyrc` configuration file:
 
 ```json
 [
     {
         "url": "https://api.openai.com/v1/chat/completions",
         "key": "...",
-        "model": "gpt-4o"
+        "model": "gpt-3.5-turbo-0125"
     }
 ]
 ```
 
 ---
 
-### Usage
-
-```bash
-# Basic usage
-npx gennady
+## 🎉 Happy Coding with Gennady!
 
-# Generate oneline commit message
-npx gennady --mode=oneline
-
-# Generate detailed commit message
-npx gennady --mode=detailed
-
-# Generate detailed commit message relative to the target branch
-npx gennady --branch=develop
-```
+> Made with 🤖 by Konstantin Lebedev

package/cli/cmd/cat.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+
+import path from 'path';
+import { catGen } from '../../src/cat-gen/cat-gen.js';
+import { style } from '../../src/utils/style.js';
+import { parseArgs } from '../../src/utils/parse-args.js';
+
+//
+// 🐱 CAT-GEN
+//
+const args = parseArgs(process.argv);
+
+if (args._.length === 0) {
+	console.error(style.yellow('Usage: npx gennady cat <path1> <path2> ...'));
+	process.exit(1);
+}
+
+catGen(args._).forEach(({ relativePath, content }) => {
+	console.log(style.blue(`#### ${relativePath}`));
+	console.log(content);
+	console.log('');
+});
+
+console.log(style.green(`^`.repeat(40)));
+console.log(style.italic.gray(`Hint: npx gennady cat ${process.argv.slice(3).join(' ')} --plain | pbcopy`));
+console.log('');

package/cli/cmd/commit.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import { CommitGen } from '../../src/commit-gen/commit-gen.js';
+import { parseArgs } from '../../src/utils/parse-args.js';
+import { style } from '../../src/utils/style.js';
+import { getSysLang } from '../../src/utils/language.js';
+
+//
+// 🤖 COMMIT-GEN 💬
+//
+
+const CACHE_PATH = path.join(os.homedir(), '.gennady_commit_cache.json');
+const PROJECT_KEY = process.cwd();
+const COMMIT_CACHE = readCache();
+
+const params = parseArgs(process.argv, {
+	apply: ['apply'],
+	mode: ['mode', 'm'],
+	oneline: ['short', 'one', 'o'],
+	model: ['model'],
+	targetBranch: ['branch', 'b'],
+	apiUrl: ['api', 'apiUrl'],
+});
+
+const commitGen = new CommitGen(params);
+
+console.info(
+	'🤖',
+	style.whiteBright.bold('GENNADY'),
+	`(${style.cyan(commitGen.model)} → ${style.yellow(commitGen.mode)})`,
+	'🗯️',
+);
+
+console.info(style.gray('-'.repeat(40)));
+console.info(`- url: ${style.blue(commitGen.apiUrl)}`);
+console.info(style.gray('-'.repeat(40)));
+
+const commitMessage = params.apply && COMMIT_CACHE[PROJECT_KEY] || await commitGen.generate();
+if (!commitMessage) {
+	process.exit(0);
+}
+
+if (params.apply) {
+	// APPLY COMMIT
+	execSync(
+		`git commit -am "${commitMessage.replace(/"/g, '\"')}"`,
+		{stdio: 'inherit'},
+	);
+	saveCache({ [PROJECT_KEY]: undefined });
+} else {
+	// GENERATE COMMIT
+	console.info('-'.repeat(40), '\n');
+	console.info(style.whiteBright(commitMessage), '\n');
+	console.info('^'.repeat(40), '\n');
+
+	const lang = getSysLang();
+	if (lang !== 'en') {
+		console.info(await commitGen.translate(commitMessage, lang), '\n');
+		console.info('^'.repeat(40), '\n');
+	}
+
+	console.log(style.italic.gray(`Hint: npx gennady ${process.argv.slice(3).join(' ')} --apply`));
+	console.log('');
+
+	saveCache({ [PROJECT_KEY]: commitMessage });
+}
+
+function readCache() {
+	try {
+		return JSON.parse(fs.readFileSync(CACHE_PATH, 'utf8'));
+	} catch {
+		return {};
+	}
+}
+
+function saveCache(patch) {
+	const next = { ...COMMIT_CACHE, ...patch };
+	fs.writeFileSync(CACHE_PATH, JSON.stringify(next, null, 2));
+}

package/cli/cmd/review.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+
+import { getGitDiffInfo } from '../../src/git/git-core.js';
+import { ReviewGen } from '../../src/review-gen/review-gen.js';
+import { parseArgs } from '../../src/utils/parse-args.js';
+import { style } from '../../src/utils/style.js';
+
+//
+// 📝 REVIEW-GEN
+//
+
+const params = parseArgs(process.argv, {
+	branch: ['branch', 'b'],
+});
+
+const review = new ReviewGen();
+
+console.info(
+	`🤖`,
+	style.whiteBright.bold(`GENNADY`),
+	`(${style.cyan(review.ai.model)})`,
+	`📝`,
+);
+
+console.info(style.gray(`-`.repeat(40)));
+
+const {
+	parsedCodeDiff,
+	parsedCodeTokens,
+	programmingLanguages,
+	parsedCodeChunkMaxTokens,
+} = getGitDiffInfo(params.branch);
+
+console.info(`- Tokens: ${style.bold.cyanBright(parsedCodeTokens)} ${style.gray(`(max per file: ${parsedCodeChunkMaxTokens})`)}`);
+console.info(`- Languages: ${style.yellow(programmingLanguages)}`);
+
+if (parsedCodeDiff.length === 0) {
+	console.info(`No changes detected, skipping review.`);
+	console.info(style.italic.gray(`Hint: git add`));
+	process.exit(0);
+}
+
+const batches = review.ai.createPromptsBatchesByDiff(parsedCodeDiff);
+
+console.info(`- Queue: ${style.bold.cyan(batches.length)}`);
+console.info(style.gray(`-`.repeat(40)));
+
+const startGenTime = performance.now();
+const results = await Promise.all(batches.map(async (batch) => {
+	console.info(`- Task:`, batch.tokens, batch.languages);
+	return await review.generate(batch.diff, batch.languages);
+}));
+
+console.info(style.gray(`-`.repeat(40)));
+console.info(`- Generation time: ${style.blueBright(((performance.now() - startGenTime) / 1000).toFixed(2))}s`);
+console.info(style.gray(`-`.repeat(40)));
+
+console.info(results.join('\n\n'));

package/cli/gennady.js

@@ -1,48 +1,24 @@
 #!/usr/bin/env node
 
-import { readFileSync } from 'fs';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-import { CommitGen } from '../src/commit-gen/commit-gen.js';
-import { parseArgs } from '../src/utils/parse-args.js';
-import { style } from '../src/utils/style.js';
-import { getSysLang } from '../src/utils/language.js';
+switch(process.argv[2]) {	
+	//
+	// 🐱 CAT-GEN
+	//
+	case 'cat':
+		import('./cmd/cat.js');
+		break;
 
-const PROMPTS_DIR = join(
-	typeof __dirname !== 'string' ? dirname(fileURLToPath(import.meta.url)) : __dirname,
-	'../src/prompts',
-);
+	//
+	// 📝 REVIEW-GEN
+	//
+	case 'review':
+		import('./cmd/review.js');
+		break;
 
-const params = parseArgs(process.argv, {
-	mode: ['mode', 'm'],
-	oneline: ['short', 'one', 'o'],
-	model: ['model'],
-	targetBranch: ['branch', 'b'],
-	apiUrl: ['api', 'apiUrl'],
-});
-
-const commit = new CommitGen({
-	...params,
-	basePromptTemplate: readFileSync(join(PROMPTS_DIR, 'base-prompt.md')).toString(),
-	formatOnelinePromptTemplate: readFileSync(join(PROMPTS_DIR, 'format-oneline-prompt.md')).toString(),
-	formatDetailedPromptTemplate: readFileSync(join(PROMPTS_DIR, 'format-detailed-prompt.md')).toString(),
-	translatePromptTemplate: readFileSync(join(PROMPTS_DIR, 'translate-prompt.md')).toString(),
-});
-
-console.info(`🤖`, style.whiteBright.bold(`GENNADY`), `(${style.cyan(commit.model)} → ${style.yellow(commit.mode)})`, `🗯️`);
-console.info(style.gray(`-`.repeat(30)));
-console.info(`- url: ${style.blue(commit.apiUrl)}`);
-console.info(style.gray(`-`.repeat(30)));
-
-const msg = await commit.generate();
-if (msg) {
-	console.info(`-`.repeat(40), '\n');
-	console.info(style.whiteBright(msg), '\n');
-	console.info(`^`.repeat(40), '\n');
-
-	const lang = getSysLang();
-	if (lang !== 'en') {
-		console.info(await commit.translate(msg, lang), '\n');
-		console.info(`^`.repeat(40), '\n');
-	}
+	//
+	// 🤖 COMMIT-GEN 💬
+	//
+	default:
+		import('./cmd/commit.js');
+		break;
 }

package/index.js

@@ -1 +1,3 @@
 export * from './src/commit-gen/commit-gen.js';
+export * from './src/git/git-diff.js';
+export * from './src/utils/language.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gennady",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "author": "Konstantin Lebedev <ibnrubaxa@gmail.com>",
   "description": "Gennady — Generate Next-level Automated Description Yntelligence",
   "keywords": [
@@ -10,7 +10,9 @@
     "local",
     "commit",
     "generator",
-    "gennady"
+    "gennady",
+    "review",
+    "code-review"
   ],
   "license": "MIT",
   "repository": "https://github.com/rubaxa/gennady",
@@ -18,6 +20,6 @@
   "bin": "./cli/gennady.js",
   "main": "index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "node --test"
   }
 }

package/src/ai/ai-core.js

@@ -0,0 +1,187 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+const DEFAULT_MODEL = 'llama3:8b';
+const DEFAULT_API_URL = 'http://127.0.0.1:11434/api/generate';
+
+const GENNADY_RC_FILENAME = '.gennadyrc';
+
+export class AiCore {
+	api = undefined;
+	apiList = [];
+
+	constructor(init) {
+		this.init = {
+			logger: console,
+			timeout: 120,
+			maxInputTokens: init.maxInputTokens || 4000,
+			...init,
+		};
+
+		// Try parse rc files
+		[
+			join(process.cwd(), GENNADY_RC_FILENAME),
+			join(process.env.HOME, GENNADY_RC_FILENAME),
+		].find((file) => {
+			try {
+				if (existsSync(file)) {
+					const items = JSON.parse(readFileSync(file).toString());
+					if (Array.isArray(items)) {
+						this.apiList.push(...items);
+					} else {
+						this.logger.warn(`Invalid "${file}" config:`, items);
+					}
+				}
+			} catch (err) {
+				this.logger.error(`Parse "${file}" error:`, err);
+			}
+		});
+		
+		// Default API
+		this.apiList[this.init.apiUrl ? 'unshift' : 'push']({
+			url: this.init.url || DEFAULT_API_URL,
+			key: this.init.key,
+			model: this.init.model || DEFAULT_MODEL,
+		});
+	}
+
+	get model() {
+		return this.api?.model || this.apiList[0].model;
+	}
+
+	get apiUrl() {
+		return this.api?.url || this.apiList[0].url;
+	}
+
+	get maxInputTokens() {
+		return this.init.maxInputTokens;
+	}
+
+	get logger() {
+		return this.init.logger;
+	}
+
+	createPromptsBatchesByDiff(parseDiff) {
+		const maxChunkTokens = parseDiff.at(-1)?.tokens || 0
+
+		if (maxChunkTokens > this.maxInputTokens) {
+			this.logger.error(`TODO: Diff is too large`);
+			process.exit(1);
+		}
+
+		const batches = parseDiff.reduce((acc, file) => {
+			if (!acc[0] || acc[0].tokens + file.tokens > this.maxInputTokens) {
+				acc.unshift({tokens: 0, diff: '', languages: []});
+			}
+
+			const fileDiff = file.diff.hunks.flatMap(h => h.changes).join('\n');
+			if (fileDiff.trim()) {
+				acc[0].tokens += file.tokens;
+				acc[0].diff += `### File **${file.filename}**:\n${fileDiff}\n\n`;
+				
+				if (!acc[0].languages.includes(file.programmingLanguage)) {
+					acc[0].languages.push(file.programmingLanguage);
+				}
+			}
+
+			return acc;
+		}, []);
+
+		return batches;
+	}
+
+	async generate(prompt, context) {
+		try {
+			const api = await this._getApi();
+			if (api.url.includes('completions')) {
+				return await this._callCompletionsApi(api, prompt, context);
+			}
+
+			return await this._callGenerateApi(api, prompt, context);
+		} catch (e) {
+			this.logger.error(`Failed to generate LLM response:`, e);
+			return '';
+		}
+	}
+
+	async _getApi() {
+		if (!this.api) {
+			// By default
+			this.api = {url: DEFAULT_API_URL, model: DEFAULT_MODEL};
+
+			for (const api of this.apiList) {
+				try {
+					const ctrl = new AbortController();
+
+					setTimeout(() => ctrl.abort(new Error('Module timeout')), 500);
+
+					const resp = await fetch(api.url, {method: 'HEAD', signal: ctrl.signal});
+					if (resp.status >= 200 && resp.status < 500) {
+						this.api = api;
+						return api;
+					}
+				} catch {}
+			}
+		}
+
+		return this.api;
+	}
+	
+	async _callGenerateApi(api, prompt, context) {
+		const req = await fetch(api.url, {
+			method: 'POST',
+			headers: {'Content-Type': 'application/json'},
+			body: JSON.stringify({
+				model: api.model,
+				stream: false,
+				prompt,
+				context,
+			}),
+		});
+		const data = await req.json();
+		return data.response || '';
+	}
+
+	async _callCompletionsApi(api, prompt, context) {
+		const messages = [];
+		
+		if (context) {
+			messages.push({ role: 'system', content: context });
+		}
+
+		messages.push({ role: 'user', content: prompt });
+
+		const req = await fetch(api.url, {
+			method: 'POST',
+			headers: {
+				'Content-Type': 'application/json',
+				'Authorization': `Bearer ${api.key}`,
+			},
+			body: JSON.stringify({
+				model: api.model,
+				messages: messages,
+				temperature: 0.1,
+				stream: false,
+				timeout: this.init.timeout,
+			}),
+		});
+
+		if (!req.ok) {
+			let errorBody = '';
+			try {
+				errorBody = await req.text();
+			} catch (e) { /* ignore */ }
+
+			throw new Error(`LLM completions request failed with status ${req.status}: ${errorBody}`);
+		}
+
+		const data = await req.json();
+		
+		if (data.choices && data.choices.length > 0 && data.choices[0].message) {
+			return data.choices[0].message.content || '';
+		} else {
+			this.logger.warn(style.yellow('LLM completions response structure unexpected:'), data);
+			return '';
+		}
+	}
+}

package/src/cat-gen/cat-gen.js

@@ -0,0 +1,53 @@
+import fs from 'fs';
+import path from 'path';
+
+export const DEFAULT_EXTENSIONS = ['.js', '.ts', '.tsx'];
+
+export const catGen = (paths, extensions = DEFAULT_EXTENSIONS) => {
+	const extSet = new Set(extensions);
+	const results = [];
+
+	const process = (inputPath) => {
+		const absoluteInputPath = path.resolve(inputPath);
+		if (!fs.existsSync(absoluteInputPath)) {
+			return;
+		}
+		
+		const initialStats = fs.statSync(absoluteInputPath);
+		const basePath = initialStats.isDirectory()
+			? absoluteInputPath
+			: path.dirname(absoluteInputPath);
+
+		const walk = (currentPath) => {
+			const stats = fs.statSync(currentPath);
+			
+			if (stats.isFile()) {
+				const ext = path.extname(currentPath).toLowerCase();
+				if (extSet.has(ext)) {
+					const relativePath = path.relative(basePath, currentPath);
+					
+					const content = fs.readFileSync(currentPath, 'utf8');
+					results.push({
+						basePath,
+						currentPath,
+						relativePath,
+						content,
+					});
+				}
+			} else if (stats.isDirectory()) {
+				const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+				for (const entry of entries) {
+					const fullEntryPath = path.join(currentPath, entry.name);
+					walk(fullEntryPath);
+				}
+			}
+		};
+
+		walk(absoluteInputPath);
+	};
+
+	(paths || []).forEach(process);
+	
+	return results;
+};
+