gennady 0.2.2 → 0.5.0

package/src/review-gen/review-gen.js

@@ -0,0 +1,119 @@
+import { AiCore } from "../ai/ai-core.js";
+import { prompts } from "../prompts/index.js";
+import { readFileSync, readdirSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const LANG_SPECS_DIR = join(
+	typeof __dirname !== 'string' ? dirname(fileURLToPath(import.meta.url)) : __dirname,
+	'specs',
+);
+
+export class ReviewGen {
+	_langSpecs = {};
+
+	constructor(init) {
+		this.init = {
+			basePromptTemplate: prompts.review('base'),
+			timeout: 120,
+
+			...init,
+		};
+
+		this.ai = new AiCore({
+			logger: this.logger,
+			timeout: this.init.timeout,
+		});
+	}
+
+	async generate(
+		code,
+		langs = [code.includes('.ts') ? 'TypeScript' : 'JavaScript'],
+	) {
+		const input = this.init.basePromptTemplate
+			.replaceAll('{LANGUAGES}', langs.join(', '))
+			.replaceAll('\n{EXTRA_RULES}\n', this._getExtraRulesPrompt(langs, code))
+			.replaceAll('{INPUT}', code);
+
+		// console.debug(`<input>${input}</input>`);
+
+		const output = await this.ai.generate(input);
+		
+		// console.info(`<output>${output}</output>`);
+
+		return output;
+	}
+
+	_getExtraRulesPrompt(langs, code) {
+		const spec = this._loadSpec(langs);
+
+		const globals = Object.keys(spec.Global.properties);
+		const rGlobals = new RegExp(`\\b(${globals.join('|')})\\b`, 'g');
+		const exists = {};
+		let prompt = '';
+		let matches = null
+
+		while (matches = rGlobals.exec(code)) {
+			const name = matches[0];
+			const {exceptions, type} = spec.Global.properties[name];
+
+			if (!exists[name]) {
+				exists[name] = true;
+				
+				if (exceptions?.length) {
+					prompt += `## ${name} handling:\n`
+					exceptions.forEach(({type, description}) => {
+						prompt += `- ${type}: ${description}\n`;
+					});
+				}
+			}
+
+			Object.entries(spec[type]?.methods || {}).forEach(([method, {exceptions, hint}]) => {
+				if (exceptions.length && code.includes(method)) {
+					const key = `${name}.${method}`;
+					if (!exists[key] && exceptions.length && hint) {
+						exists[key] = true;
+						
+						prompt += `## **${key}** handling:\n`;
+						prompt += hint.join('\n');
+						
+						// exceptions.forEach(({type, description}) => {
+						// 	prompt += `- ${type}: ${description}\n`;
+						// });
+					}
+					
+				}
+			});
+		}
+
+		return prompt ? `\n${prompt}\n` : '';
+	}
+
+	_loadSpec(langs) {
+		return langs.reduce((spec, lang) => {
+			const specName = lang === 'JavaScript' || lang === 'TypeScript' ? 'js' : lang;
+			const specPath = join(LANG_SPECS_DIR, specName);
+
+			this._langSpecs[specName] = {};
+			
+			for (const entry of readdirSync(specPath)) {
+				if (!entry.endsWith('.json')) {
+					continue;
+				}
+
+				const rawJson = readFileSync(join(specPath, entry)).toString();
+				const json = JSON.parse(rawJson);
+
+				Object.assign(this._langSpecs[specName], json);
+			}
+
+			return {
+				...spec,
+				...this._langSpecs[specName],
+			};
+		}, {});
+	}
+}
+
+
+

package/src/review-gen/review-gen.test.js

@@ -0,0 +1,79 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { test, describe } from 'node:test';
+import assert from 'node:assert';
+import { ReviewGen } from './review-gen.js';
+
+describe('review', async () => {
+	const reviewGen = new ReviewGen();
+	const fixtures = getFixture();
+
+	fixtures.forEach(({ name, diff, expected }) => {
+		test(name, async () => {
+			const result = (await reviewGen.generate(diff)).trim();
+
+			if (expected.includes('GOOD')) {
+				assert.strictEqual(result.includes('GOOD'), true, `Test '${name}': Expected 'GOOD', got: '${result}'`);
+				return;
+			}
+
+			if (!expected || expected.length === 0) {
+				assert.fail(`Test '${name}': Invalid or empty 'expected' rules.`);
+			}
+
+			expected.forEach(ruleString => {
+				const suggestion = result.match(/suggestion\n([\s\S]+)/)?.[1] || ''
+				const rule = createRule(ruleString);
+				const expectationText = rule.isNegation ? 'SHOULD NOT match' : 'SHOULD match';
+				const matchResult = rule.regexp.test(suggestion);
+
+				assert.strictEqual(
+					matchResult,
+					!rule.isNegation,
+					`Test '${name}': Output ${expectationText} ${rule.regexp}.\nOutput: '${suggestion}'`
+				);
+			});
+		});
+	});
+});
+
+function createRule(ruleString) {
+	const isNegation = ruleString.startsWith('!');
+	const pattern = isNegation ? ruleString.slice(1) : ruleString;
+	const regexp = new RegExp(pattern.replace(/^\/|\/$/g, ''));
+	return { regexp, isNegation, pattern };
+}
+
+function getFixture() {
+	const filePath = join(
+		typeof __dirname !== 'string' ? dirname(fileURLToPath(import.meta.url)) : __dirname,
+		'__fixture__',
+		'review-gen-fixture.md',
+	);
+	const text = readFileSync(filePath).toString();
+	const blocks = text.trim().split('\n----\n').filter(Boolean);
+	const results = [];
+	const regex = /^### (.*?)\s*\n+#### Diff\s*\n+```diff\s*\n(.*?)\n```\s*\n+#### Expected\s*\n+(.*)/si;
+
+	for (const block of blocks) {
+		const match = block.trim().match(regex);
+		if (!match) continue;
+
+		const name = match[1].trim();
+		const diff = match[2].trim();
+		let expectedText = match[3].trim();
+
+		if (expectedText.startsWith('```')) {
+			const lines = expectedText.split('\n');
+			expectedText = lines.length > 1 ? lines.slice(1, -1).join('\n').trim() : '';
+		}
+
+		const expected = expectedText === 'OK'
+			? 'OK'
+			: expectedText.split('\n').map(r => r.trim().replace(/-\s*/g, '')).filter(Boolean);
+
+		results.push({ name, diff, expected });
+	}
+	return results;
+}

package/src/review-gen/specs/js/Function.prototype.json

@@ -0,0 +1,162 @@
+{
+	"Function.prototype": {
+		"description": "The prototype object for all Function objects. It is itself a built-in function object but cannot be used as a constructor.",
+		"properties": {
+			"constructor": {
+				"value": "Function",
+				"attributes": {
+					"writable": true,
+					"enumerable": false,
+					"configurable": true
+				},
+				"description": "The constructor function that created the instance object. For Function instances, this is the Function constructor."
+			},
+			"length": {
+				"value": 0,
+				"attributes": {
+					"writable": false,
+					"enumerable": false,
+					"configurable": true
+				},
+				"description": "The number of formal parameters expected by the Function.prototype function itself, which is 0."
+			},
+			"name": {
+				"value": "\"\"",
+				"attributes": {
+					"writable": false,
+					"enumerable": false,
+					"configurable": true
+				},
+				"description": "The name of the Function.prototype function itself, which is the empty string."
+			}
+		},
+		"methods": {
+			"apply": {
+				"description": "Calls the function with a given `this` value and arguments provided as an array (or an array-like object).",
+				"arguments": [
+					{
+						"name": "thisArg",
+						"required": false,
+						"description": "The value to be passed as the `this` parameter to the target function. If the function is non-strict, `null` or `undefined` will be replaced with the global object, and primitive values will be boxed."
+					},
+					{
+						"name": "argArray",
+						"required": false,
+						"description": "An array-like object, specifying the arguments with which the function should be called, or `null` or `undefined` if no arguments are provided."
+					}
+				],
+				"returns": {
+					"type": "any",
+					"description": "The result of calling the function with the specified `this` value and arguments."
+				},
+				"exceptions": [
+					{
+						"type": "TypeError",
+						"description": "If the `this` value (the function being called) is not callable."
+					},
+					{
+						"type": "TypeError",
+						"description": "If `argArray` is provided but cannot be converted to a list (e.g., is not array-like or throws during iteration)."
+					}
+				]
+			},
+			"bind": {
+				"description": "Creates a new function that, when called, has its `this` keyword set to the provided value, with a given sequence of arguments preceding any provided when the new function is called.",
+				"arguments": [
+					{
+						"name": "thisArg",
+						"required": true,
+						"description": "The value to be passed as the `this` parameter to the target function when the bound function is called. Ignored if the target function is an arrow function or already bound."
+					},
+					{
+						"name": "args",
+						"required": false,
+						"variadic": true,
+						"description": "Arguments to prepend to arguments provided to the bound function when invoking the target function."
+					}
+				],
+				"returns": {
+					"type": "Function",
+					"description": "A new bound function object with the specified `this` value and initial arguments."
+				},
+				"exceptions": [
+					{
+						"type": "TypeError",
+						"description": "If the `this` value (the target function) is not callable."
+					},
+					{
+						"type": "TypeError",
+						"description": "If reading the 'length' or 'name' property of the target function throws an error (potential UserCodeError)."
+					}
+				]
+			},
+			"call": {
+				"description": "Calls the function with a given `this` value and arguments provided individually.",
+				"arguments": [
+					{
+						"name": "thisArg",
+						"required": false,
+						"description": "The value to be passed as the `this` parameter to the target function. If the function is non-strict, `null` or `undefined` will be replaced with the global object, and primitive values will be boxed."
+					},
+					{
+						"name": "args",
+						"required": false,
+						"variadic": true,
+						"description": "Arguments for the function."
+					}
+				],
+				"returns": {
+					"type": "any",
+					"description": "The result of calling the function with the specified `this` value and arguments."
+				},
+				"exceptions": [
+					{
+						"type": "TypeError",
+						"description": "If the `this` value (the function being called) is not callable."
+					}
+				]
+			},
+			"toString": {
+				"description": "Returns a string representing the source code of the function.",
+				"arguments": [],
+				"returns": {
+					"type": "String",
+					"description": "A string containing the source code representation of the function. For built-in functions or bound functions, the format is implementation-defined but should resemble 'function name() { [native code] }'."
+				},
+				"exceptions": [
+					{
+						"type": "TypeError",
+						"description": "If the `this` value is not a callable Object or if its source text is unavailable and it's not a recognized function type."
+					}
+				]
+			}
+		},
+		"symbols": {
+			"[Symbol.hasInstance]": {
+				"description": "Used by the `instanceof` operator. Determines if a constructor function recognizes an object as its instance.",
+				"attributes": {
+					"writable": false,
+					"enumerable": false,
+					"configurable": false
+				},
+				"arguments": [
+					{
+						"name": "V",
+						"required": true,
+						"description": "The value to check."
+					}
+				],
+				"returns": {
+					"type": "Boolean",
+					"description": "`true` if `V` is considered an instance of the function; `false` otherwise. Based on prototype chain checks by default."
+				},
+				"exceptions": [
+					{
+						"type": "TypeError",
+						"description": "If the `this` value (the function) is not an object, or if checking the prototype chain fails (e.g., accessing prototype throws)."
+					}
+				]
+			}
+		}
+	}
+}

package/src/review-gen/specs/js/Global.json

@@ -0,0 +1,219 @@
+{
+	"Global": {
+		"description": "Function Properties of the Global Object",
+		"properties": {
+			"localStorage": {
+				"description": "Provides access to a Storage object for the document's origin, saved across browser sessions. Data has no expiration time (except in private browsing modes).",
+				"type": "Storage",
+				"readOnly": true,
+				"exceptions": [
+					{
+					"type": "SecurityError",
+					"description": "Thrown upon access if the origin is invalid (e.g., file:, data:) or if storage access is disallowed by policy/user settings (e.g., blocking cookies)."
+					}
+				]
+			},
+			"sessionStorage": {
+				"description": "Provides access to a Storage object for the document's origin, cleared when the page session ends (e.g., when the browser tab is closed).",
+				"type": "Storage",
+				"readOnly": true,
+				"exceptions": [
+					{
+					"type": "SecurityError",
+					"description": "Thrown upon access if the origin is invalid (e.g., file:, data:) or if storage access is disallowed by policy/user settings (e.g., blocking cookies)."
+					}
+				]
+			},
+			"JSON": {
+				"type": "JSON"
+			}
+		},
+		"methods": {
+			"isFinite": {
+				"description": "Determines whether the passed value is a finite number.",
+				"arguments": [
+					{
+						"name": "number",
+						"required": true,
+						"description": "The value to be tested for finiteness."
+					}
+				],
+				"returns": {
+					"type": "Boolean",
+					"description": "`false` if the argument coerces to `NaN`, positive `Infinity`, or negative `Infinity`; otherwise, `true`."
+				},
+				"exceptions": [
+					{
+						"type": "TypeError",
+						"description": "If the `number` argument cannot be converted to a Number (e.g., it's a Symbol or an object with faulty conversion methods)."
+					}
+				]
+			},
+			"isNaN": {
+				"description": "Determines whether the passed value is NaN.",
+				"arguments": [
+					{
+						"name": "number",
+						"required": true,
+						"description": "The value to be tested for NaN."
+					}
+				],
+				"returns": {
+					"type": "Boolean",
+					"description": "`true` if the given value coerces to `NaN`; otherwise, `false`."
+				},
+				"exceptions": [
+					{
+						"type": "TypeError",
+						"description": "If the `number` argument cannot be converted to a Number (e.g., it's a Symbol or an object with faulty conversion methods)."
+					}
+				]
+			},
+			"parseFloat": {
+				"description": "Parses a string argument and returns a floating-point number.",
+				"arguments": [
+					{
+						"name": "string",
+						"required": true,
+						"description": "The string to parse."
+					}
+				],
+				"returns": {
+					"type": "Number",
+					"description": "A floating-point number parsed from the given string. If the first character cannot be converted to a number, `NaN` is returned."
+				},
+				"exceptions": [
+					{
+						"type": "TypeError",
+						"description": "If the `string` argument cannot be converted to a String (e.g., it's a Symbol or an object with faulty conversion methods)."
+					}
+				]
+			},
+			"parseInt": {
+				"description": "Parses a string argument and returns an integer of the specified radix (the base in mathematical numeral systems).",
+				"arguments": [
+					{
+						"name": "string",
+						"required": true,
+						"description": "The string to parse."
+					},
+					{
+						"name": "radix",
+						"required": false,
+						"description": "An integer between 2 and 36 that represents the radix (the base in mathematical numeral systems) of the string. If omitted or 0, it is assumed to be 10, except when the number begins with the code unit pairs '0x' or '0X', in which case a radix of 16 is assumed."
+					}
+				],
+				"returns": {
+					"type": "Number",
+					"description": "An integer parsed from the given string. If the radix is smaller than 2 or bigger than 36, or the first non-whitespace character cannot be converted to a number, `NaN` is returned."
+				},
+				"exceptions": [
+					{
+						"type": "TypeError",
+						"description": "If the `string` argument cannot be converted to a String."
+					},
+					{
+						"type": "TypeError",
+						"description": "If the `radix` argument cannot be converted to a Number (when performing ToInt32)."
+					}
+				]
+			},
+			"decodeURI": {
+				"description": "Computes a new version of a URI by replacing UTF-8 escape sequences created by encodeURI with the characters they represent. Escape sequences that could not have been introduced by encodeURI are not replaced.",
+				"arguments": [
+					{
+						"name": "encodedURI",
+						"required": true,
+						"description": "A String representing an encoded URI."
+					}
+				],
+				"returns": {
+					"type": "String",
+					"description": "A new string representing the decoded URI."
+				},
+				"exceptions": [
+					{
+						"type": "TypeError",
+						"description": "The `encodedURI` argument cannot be converted to a String."
+					},
+					{
+						"type": "URIError",
+						"description": "The `encodedURI` contains a malformed percent-encoded sequence or an invalid UTF-8 sequence."
+					}
+				]
+			},
+			"decodeURIComponent": {
+				"description": "Computes a new version of a URI component by replacing UTF-8 escape sequences created by encodeURIComponent with the characters they represent.",
+				"arguments": [
+					{
+						"name": "encodedURIComponent",
+						"required": true,
+						"description": "A String representing an encoded URI component."
+					}
+				],
+				"returns": {
+					"type": "String",
+					"description": "A new string representing the decoded URI component."
+				},
+				"exceptions": [
+					{
+						"type": "TypeError",
+						"description": "The `encodedURIComponent` argument cannot be converted to a String."
+					},
+					{
+						"type": "URIError",
+						"description": "The `encodedURIComponent` contains a malformed percent-encoded sequence or an invalid UTF-8 sequence."
+					}
+				]
+			},
+			"encodeURI": {
+				"description": "Computes a new version of a URI by replacing instances of certain characters with their UTF-8 escape sequences. Assumes the input is a complete URI, so reserved characters (';', '/', '?', ':', '@', '&', '=', '+', '$', ',', '#') are not encoded.",
+				"arguments": [
+					{
+						"name": "uri",
+						"required": true,
+						"description": "A String representing a complete URI."
+					}
+				],
+				"returns": {
+					"type": "String",
+					"description": "A new string representing the encoded URI."
+				},
+				"exceptions": [
+					{
+						"type": "TypeError",
+						"description": "The `uri` argument cannot be converted to a String."
+					},
+					{
+						"type": "URIError",
+						"description": "The `uri` contains an unpaired surrogate code point."
+					}
+				]
+			},
+			"encodeURIComponent": {
+				"description": "Computes a new version of a URI component by replacing instances of certain characters with their UTF-8 escape sequences. Assumes the input is a component of a URI, so characters reserved in URIs (';', '/', '?', ':', '@', '&', '=', '+', '$', ',', '#') are encoded.",
+				"arguments": [
+					{
+						"name": "uriComponent",
+						"required": true,
+						"description": "A String representing a URI component."
+					}
+				],
+				"returns": {
+					"type": "String",
+					"description": "A new string representing the encoded URI component."
+				},
+				"exceptions": [
+					{
+						"type": "TypeError",
+						"description": "The `uriComponent` argument cannot be converted to a String."
+					},
+					{
+						"type": "URIError",
+						"description": "The `uriComponent` contains an unpaired surrogate code point."
+					}
+				]
+			}
+		}
+	}
+}

package/src/review-gen/specs/js/JSON.json

@@ -0,0 +1,85 @@
+{
+  "JSON": {
+    "description": "The JSON object provides methods to parse JSON strings and convert values to JSON strings.",
+    "methods": {
+      "parse": {
+        "description": "Parses a JSON string, constructing the JavaScript value or object described by the string.",
+        "arguments": [
+          {
+            "name": "text",
+            "required": true,
+            "description": "A String containing the JSON-formatted text."
+          },
+          {
+            "name": "reviver",
+            "required": false,
+            "description": "A function that can filter and transform the results."
+          }
+        ],
+        "returns": {
+          "type": "any",
+          "description": "The ECMAScript value corresponding to the JSON text (Object, Array, String, Number, Boolean, or null)."
+        },
+        "exceptions": [
+          {
+            "type": "SyntaxError",
+            "description": "The input string `text` is not valid JSON text."
+          },
+          {
+            "type": "TypeError",
+            "description": "The `text` argument cannot be converted to a String."
+          },
+          {
+            "type": "UserCodeError",
+            "description": "An error was thrown by the `reviver` function."
+          }
+        ],
+        "hint": [
+          "When you identify an unsafe `JSON.parse` call in the code review, your generated `suggestion` should follow the pattern shown in this reference example: wrap the call in `try...catch`, log the error and then return `null`."
+        ]
+      },
+      "stringify": {
+        "description": "Converts a JavaScript value to a JSON string, optionally replacing values or including only specified properties.",
+        "arguments": [
+          {
+            "name": "value",
+            "required": true,
+            "description": "The JavaScript value to convert to a JSON string."
+          },
+          {
+            "name": "replacer",
+            "required": false,
+            "description": "A function that alters the stringification process, or an array of Strings/Numbers used as an inclusion list for properties."
+          },
+          {
+            "name": "space",
+            "required": false,
+            "description": "A String or Number used to insert white space into the output JSON string for readability."
+          }
+        ],
+        "returns": {
+          "type": "String | undefined",
+          "description": "A JSON string representing the given value, or `undefined` if the value (or the value returned by `replacer` or `toJSON`) is `undefined`, a `Function`, or a `Symbol`."
+        },
+        "exceptions": [
+          {
+            "type": "TypeError",
+            "description": "A cyclic structure was found in the `value`."
+          },
+          {
+            "type": "TypeError",
+            "description": "Attempted to serialize a BigInt value."
+          },
+          {
+            "type": "UserCodeError",
+            "description": "An error was thrown by the `toJSON` method of an object."
+          },
+          {
+            "type": "UserCodeError",
+            "description": "An error was thrown by the `replacer` function."
+          }
+        ]
+      }
+    }
+  }
+}