gennady 0.3.0 → 0.5.0

package/src/commit-gen/commit-gen.js

@@ -1,18 +1,9 @@
-import { readFileSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { getGitCommitCount, getGitDiff } from '../git/git-cmd.js';
-import { parseGitDiff } from '../git/git-diff.js';
+import { AiCore } from '../ai/ai-core.js';
+import { getGitDiffInfo } from '../git/git-core.js';
+import { prompts } from '../prompts/index.js';
 import { style } from '../utils/style.js';
 
-const DEFAULT_MODEL = 'llama3:8b';
-const DEFAULT_API_URL = 'http://127.0.0.1:11434/api/generate';
-
-const GENNADY_RC_FILENAME = '.gennadyrc';
-
 export class CommitGen {
-	api;
-	apiList = [];
-
 	constructor(init) {
 		this.init = {
 			mode: 'auto',
@@ -20,42 +11,20 @@ export class CommitGen {
 			targetBranch: undefined,
 
 			logger: console,
-			maxInputTokens: init.maxInputTokens || 4000,
 
-			basePromptTemplate: undefined,
-			formatOnelinePromptTemplate: undefined,
-			formatDetailedPromptTemplate: undefined,
-			translatePromptTemplate: undefined,
+			basePromptTemplate: prompts.commit('base'),
+			formatOnelinePromptTemplate: prompts.commit('format-oneline'),
+			formatDetailedPromptTemplate: prompts.commit('format-detailed'),
+			translatePromptTemplate: prompts.commit('translate'),
 
 			timeout: 120,
 
 			...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.apiUrl || DEFAULT_API_URL,
-			key: this.init.apiKey,
-			model: this.init.model || DEFAULT_MODEL,
+		this.ai = new AiCore({
+			logger: this.logger,
+			timeout: this.init.timeout,
 		});
 	}
 
@@ -68,168 +37,53 @@ export class CommitGen {
 	}
 
 	get model() {
-		return this.api?.model || this.apiList[0].model;
+		return this.ai.model
 	}
 
 	get apiUrl() {
-		return this.api?.url || this.apiList[0].url;
+		return this.ai.apiUrl;
 	}
 
 	get targetBranch() {
 		return this.init.targetBranch;
 	}
 
-	generateDiffText(files) {
-		return files
-			.map((file) => `File: ${file.filename}\n${file.diff.join('\n')}`)
-			.join('\n\n');
-	}
-
-	async getApi() {
-		if (!this.api) {
-			// By default
-			this.api = {url: DEFAULT_API_URL, model: DEFAULT_MODEL};
-
-			for (const api of this.apiList) {
-				try {
-					const resp = await fetch(api.url, {method: 'HEAD', timeout: 1000});
-					if (resp.status >= 200 && resp.status < 500) {
-						this.api = api;
-						return api;
-					}
-				} catch {}
-			}
-		}
-
-		return this.api;
-	}
-
-	async fetchPrompt(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 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 '';
-		}
-	}
-
-	async generateCommitMessage(prompt) {
-		const text = await this.fetchPrompt(prompt);
-		return text;
+	async fetchPrompt(input) {
+		const output = await this.ai.generate(input);
+		return output;
 	}
 
 	async generate() {
-		const {maxInputTokens} = this.init
-		const commitCount = getGitCommitCount();
-		const diffStr = getGitDiff(this.init.targetBranch);
-		const parsedDiff = parseGitDiff(diffStr).sort((a, b) => a.tokens - b.tokens);
-		const codeChanged = parsedDiff.filter(f => !f.isDeleted && !f.isRenamed && f.programmingLanguage);
+		const {
+			commitCount,
+			parsedCodeDiff,
+			parsedCodeTokens,
+			parsedCodeChunkMaxTokens,
+			programmingLanguages,
+		} = getGitDiffInfo(this.init.targetBranch);
 		
-		if (codeChanged.length === 0) {
+		if (parsedCodeDiff.length === 0) {
 			this.logger.warn(`No changes detected, skipping commit message generation.`);
+			this.logger.info(style.italic.gray(`Hint: git add .`));
 			return;
 		}
 
-		const tokens = codeChanged.reduce((sum, file) => sum + file.tokens, 0);
-		const maxTokens = codeChanged[codeChanged.length - 1].tokens;
-		const languages = [...new Set(codeChanged.map(f => f.programmingLanguage).filter(Boolean))].join(', ');
 		const mode =
 			this.init.oneline
 			? 'oneline'
 			: this.init.mode === 'auto'
 			? this.init.targetBranch
 			? 'detailed'
-			: commitCount > 1 && codeChanged.length < 5
+			: commitCount > 1 && parsedCodeDiff.length < 5
 			? 'oneline'
 			: 'detailed'
 			: this.init.mode;
 
 		this.logger.info(`- Mode: ${style.bold.magentaBright(mode)}`);
-		this.logger.info(`- Languages: ${style.yellow(languages)}`);
-		this.logger.info(`- Tokens: ${style.bold.cyanBright(tokens)} ${style.gray(`(max per file: ${maxTokens})`)}`);
+		this.logger.info(`- Languages: ${style.yellow(programmingLanguages)}`);
+		this.logger.info(`- Tokens: ${style.bold.cyanBright(parsedCodeTokens)} ${style.gray(`(max per file: ${parsedCodeChunkMaxTokens})`)}`);
 
-		if (maxTokens > maxInputTokens) {
-			this.logger.error(`TODO: Diff is too large, skipping commit message generation.`);
-			process.exit(1);
-		}
-
-		const batches = codeChanged.reduce((acc, file) => {
-			if (!acc[0] || acc[0].tokens + file.tokens > maxInputTokens) {
-				acc.unshift({tokens: 0, diff: '', languages: []});
-			}
-
-			acc[0].tokens += file.tokens;
-			acc[0].diff += `File: ${file.filename}\n${file.diff.hunks.flatMap(h => h.changes).join('\n')}\n\n`;
-			
-			if (!acc[0].languages.includes(file.programmingLanguage)) {
-				acc[0].languages.push(file.programmingLanguage);
-			}
-
-			return acc;
-		}, []);
+		const batches = this.ai.createPromptsBatchesByDiff(parsedCodeDiff);
 
 		this.logger.info(`- Queue: ${style.bold.cyan(batches.length)}`);
 		this.logger.info(`-`.repeat(40));
@@ -242,7 +96,7 @@ export class CommitGen {
 				.replaceAll('{languages}', batch.languages.join('/'))
 				.replaceAll('{input}', batch.diff);
 
-			const msg = await this.generateCommitMessage(prompt);
+			const msg = await this.fetchPrompt(prompt);
 
 			return msg
 		}));
@@ -255,6 +109,7 @@ export class CommitGen {
 			mode === 'detailed' ? this.init.formatDetailedPromptTemplate : this.init.formatOnelinePromptTemplate,
 			results.join('\n\n'),
 		);
+
 		this.logger.info(`- Formatting time: ${style.blueBright(((performance.now() - startFormatTime) / 1000).toFixed(2))}s`);
 
 		return formatted.trim();

package/src/git/git-core.js

@@ -0,0 +1,69 @@
+import { execSync as nodeExecSync } from 'node:child_process';
+import { parseGitDiff } from './git-diff.js';
+
+const execSync = (cmd) => {
+	try {
+		return nodeExecSync(cmd, { encoding: 'utf-8'});
+	} catch (e) {
+		return '';
+	}
+}
+	
+export const detectGitBaseBranch = () => {
+	const branchesOutput = execSync('git branch --list 2>/dev/null');
+	const match = branchesOutput?.match(/\s*\*?\s*(master|main)$/m);
+	return match?.[1] || 'master';
+}
+
+export const getGitCommitCount = () => {
+	try {
+		const output = execSync(`git rev-list --count HEAD ^${detectGitBaseBranch()} 2>/dev/null`);
+		return parseInt(output, 10) || 0;
+	} catch {
+		return 0;
+	}
+}
+
+export const getGitDiff = (targetBranch = undefined) => {
+	if (targetBranch) {
+		return execSync(`git diff ${targetBranch}`);
+	}
+
+	return execSync('git diff HEAD');
+}
+
+export const getGitDiffInfo = (branch = undefined) => {
+	const diff = getGitDiff(branch);
+	const parsedDiff = parseGitDiff(diff).sort((a, b) => a.tokens - b.tokens);
+	const parsedCodeDiff = parsedDiff.filter(f => (
+		!f.isDeleted &&
+		!f.isRenamed &&
+		!/\.(test|spec)s?\./.test(f.filename) &&
+		(
+			f.category === 'config' ||
+			f.programmingLanguage
+		)
+	));
+	
+	// Если ничего нет, то подмешиваем документацию
+	if (!parsedCodeDiff.length) {
+		parsedCodeDiff.push(
+			...parsedDiff.filter(f => !f.isDeleted && !f.isRenamed && f.category === 'doc')
+		);
+	}
+
+	const parsedCodeTokens = parsedCodeDiff.reduce((sum, file) => sum + file.tokens, 0);
+	const parsedCodeChunkMaxTokens = parsedCodeDiff.at(-1)?.tokens || 0;
+
+	const programmingLanguages = [...new Set(parsedCodeDiff.map(f => f.programmingLanguage).filter(Boolean))];
+
+	return {
+		diff,
+		parsedDiff,
+		parsedCodeDiff,
+		parsedCodeTokens,
+		parsedCodeChunkMaxTokens,
+		programmingLanguages,
+		commitCount: getGitCommitCount(),
+	};
+}

package/src/git/git-diff.js

@@ -1,6 +1,41 @@
 import { getProgrammingLanguage } from "../utils/language.js";
 import { countTokens } from "../utils/tokens.js";
 
+const CONFIG_FILE_PATTERNS = [
+	'^package\\.json',
+	'^tsconfig\\.json',
+	'^babel\\.config\\.json',
+	'^\\.pnpmfile\\.cjs',
+	'^\\.yarnrc(?:\\.(?:yml|yaml))?',
+	'^go\\.(?:mod|sum)',
+	'^\\.env(?:\\.[\\w]+)?',
+	'^\\..+',
+	'.*\\.(?:yml|yaml|rc|ini|conf)'
+];
+
+const LOCKFILE_PATTERNS = [
+	'^package-lock\\.json',
+	'^npm-shrinkwrap\\.json',
+	'^yarn(?:-lock)?\\.(?:yaml|yml|toml)',
+	'^pnpm-lock\\.yaml',
+	'^composer\\.lock',
+	'^podfile\\.lock',
+	'^go\\.sum',
+	'^gemfile\\.lock'
+];
+
+const FILE_CATEGORY_REGEX = {
+	doc: /\.(md|markdown|txt|rst)$/i,
+	cfg: new RegExp(CONFIG_FILE_PATTERNS.join('|'), 'i'),
+	img: /\.(png|jpe?g|gif|svg|bmp|tiff|ico)$/i,
+	css: /\.(css|less|scss|sass|styl)$/i,
+	html: /\.(html?)$/i,
+	code: /\.(js|jsx|ts|tsx|java|py|c|cpp|cs|rb|php|go|swift|m|mm|kt)$/i,
+	bin: /^(exe|dll|so|bin)\b/i,
+	lock: new RegExp(LOCKFILE_PATTERNS.join('|'), 'i'),
+	json: /\.json$/i
+};
+
 const getCategory = (filename, metadata) => {
 	if (metadata && metadata.extra && Array.isArray(metadata.extra)) {
 		for (let line of metadata.extra) {
@@ -10,19 +45,7 @@ const getCategory = (filename, metadata) => {
 		}
 	}
 
-	const categories = {
-		bin: /^(exe|dll|so|bin)\b$/i,
-		lock: /^(package-lock\.json|yarn\.lock|npm-shrinkwrap\.json|composer\.lock|podfile\.lock|go\.sum|gemfile\.lock)$/i,
-		json: /\.json$/i,
-		doc: /\.(md|markdown|txt|rst)$/i,
-		cfg: /^(\..+|.*\.(yml|yaml|rc|ini|conf))$/i,
-		img: /\.(png|jpe?g|gif|svg|bmp|tiff|ico)$/i,
-		css: /\.(css|less|scss|sass|styl)$/i,
-		html: /\.(html?)$/i,
-		code: /\.(js|jsx|ts|tsx|java|py|c|cpp|cs|rb|php|go|swift|m|mm|kt)$/i,
-	};
-
-	const category = Object.entries(categories).find(
+	const category = Object.entries(FILE_CATEGORY_REGEX).find(
 		([, regexp]) => regexp.test(filename)
 	)?.[0] || 'other';
 

package/src/prompts/commit/commit-base-prompt.md

@@ -0,0 +1,38 @@
+You are a {languages} expert tasked with writing a Git commit subject and description based on the provided git diff.
+
+# Instructions:
+## Subject:
+- **MUST follow Conventional Commits format: `<type>: <subject> emoji`**.
+- **Choose the best <type> (e.g., `feat`, `fix`, `refactor`, `chore`, `docs`, `style`, `test`, `perf`) based on the *main purpose* of the changes.**
+- The `<subject>` should be concise yet informative.
+- Do not describe changes for each file in the subject.
+- Do not mention stylistic changes or fixed typos in the subject (unless the type is `style` or `chore`).
+- The subject must provide enough context to understand the commit at a glance.
+- End the entire subject line with an emoji instead of a period.
+
+### Subject Examples:
+- `feat: added user authentication endpoint 🚀`
+- `fix: calculation error on invoice generation 🐛`
+- `refactor: simplified internal API calls ✨`
+- `docs: updated setup instructions 📝`
+- `chore: configured linting rules ⚙️`
+
+## Description:
+- Expand on the changes by listing key modifications as an unordered list.
+- Do not describe changes for each file.
+- Do not mention stylistic changes or fixed typos.
+- Group related changes into single points.
+- Each list item **must** be less than 140 characters and should not end with a period.
+
+## Output Format (any deviation from this format is incorrect):**
+<message><type>: <subject> emoji
+- description item 1
+- description item 2</message>
+
+## Extremely important:
+- The output must contain only commit message inside `<message>` and `</message>`.
+- Do not add unnecessary words and markup, strictly follow the output format.
+- The subject line MUST start with a valid Conventional Commit type followed by a colon and a space.
+
+# Git diff:
+{input}

package/src/prompts/commit/commit-format-detailed-prompt.md

@@ -0,0 +1,29 @@
+You are a {languages} expert tasked with writing a Git commit subject and description based on code changes.
+
+# Instructions:
+## Correct Output Format (no deviations allowed):
+<message>
+<type>: <subject> emoji
+- description item 1
+- description item 2
+- description item N
+</message>
+
+## Subject:
+- **MUST follow Conventional Commits format: `<type>: <subject> emoji`**.
+- **Choose the best <type> (e.g., `feat`, `fix`, `refactor`, `chore`, `docs`, `style`, `test`, `perf`) based on the *main purpose* of the changes.**
+- The `<subject>` should be concise yet informative, without loss of meaning.
+- The commit subject (including `<type>: ` and emoji) must be no more than 72 characters.
+
+## Description:
+- Expand on the changes by listing key modifications as an unordered list.
+- Each list item **must** be brief, informative, and less than 140 characters.
+- Do not end description items with a period.
+
+## Extremely Important:
+- The output must contain *only* the commit message inside `<message>` and `</message>`.
+- Do not include extra words, explanations, or markup beyond the specified format.
+- End the commit subject with an emoji instead of a period.
+
+# Input:
+{input}

package/src/prompts/commit/commit-format-oneline-prompt.md

@@ -0,0 +1,19 @@
+You are a {languages} expert tasked with writing a Git commit message based on code changes.  
+
+# Instructions:
+## Correct Output Format (no deviations allowed):
+<message><type>: <subject> emoji</message>
+
+## Message:
+- **MUST follow Conventional Commits format: `<type>: <subject> emoji`**.
+- **Choose the best <type> (e.g., `feat`, `fix`, `refactor`, `chore`, `docs`, `style`, `test`, `perf`) based on the *main purpose* of the changes.**
+- The `<subject>` should be concise yet informative, without loss of meaning.
+- The commit message should be no more than 72 characters.
+
+## Extremely important:
+- The output must contain only the commit message inside `<message>` and `</message>`.
+- Do not add unnecessary words or markup; strictly follow the output format.
+- End the commit message with an emoji instead of a period.
+
+# Input:
+{input}

package/src/prompts/commit/commit-translate-prompt.md

@@ -0,0 +1,15 @@
+You are an expert in translating from English to **{lang}**.
+
+# Instructions:
+## Translate:
+Translate text inside `<message>` and `</message>` tags from English to **{lang}**.
+
+## Output format:
+<message>Translation result</message>
+
+## Extremely important:
+- The translation must be wrapped inside `<message>` and `</message>` tags.
+- Do not add unnecessary words and markup, strictly follow the output format.
+
+# Input for translate to **{lang}**:
+{input}

package/src/prompts/index.js

@@ -0,0 +1,10 @@
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const PROMPTS_DIR = typeof __dirname !== 'string' ? dirname(fileURLToPath(import.meta.url)) : __dirname;
+
+export const prompts = {
+	commit: (name) => readFileSync(join(PROMPTS_DIR, `commit`, `commit-${name}-prompt.md`)).toString(),
+	review: (name) => readFileSync(join(PROMPTS_DIR, `review`, `review-${name}-prompt.md`)).toString(),
+};

package/src/prompts/review/review-base-prompt.md

@@ -0,0 +1,46 @@
+You are a meticulous Code Review Bot focused on identifying **critical errors** in {LANGUAGES} code changes. Your primary goal is to ensure the modified code is **functionally correct, safe, and free of obvious bugs** based *only* on the provided git diff. You must avoid subjective opinions or suggestions for alternative approaches if the code works as intended.
+
+# Input:
+{INPUT}
+
+# Task:
+1. Analyze **ONLY** the lines starting with `+` lines in the git diff. Ignore surrounding code unless it's directly impacted by the change causing an error.
+2. Identify **only critical issues** based on the definition below.
+3. Provide concise feedback in two sections: `Issues` and `Suggestions`.
+4. If **no critical issues** are found in the changes, output **ONLY one token `GOOD`**.
+
+# Definition of a "Critical Issue":
+Focus **exclusively** on:
+- **Logic Errors:** Code produces obviously incorrect results based on the diff.
+- **Runtime Errors:** Code is highly likely to crash (e.g., `null` access, unhandled exceptions on external input).
+- **Security Vulnerabilities:** This includes:
+  - Obvious risks like XSS, SQL Injection, hardcoded secrets.
+  - **Logging Sensitive Data:** Check any operation that outputs data (to logs, console, files, etc.). If the **name** of a variable or data field being outputted **contains** (case-insensitive) substrings like `'password'`, `'token'`, `'secret'`, `'apiKey'`, or `'credential'`, report this as a critical issue. **If the names being outputted do NOT contain these specific substrings, DO NOT report a logging-related security issue.**
+
+**DO NOT Report:**
+- Stylistic preferences (formatting, naming conventions, etc.).
+- Suggestions for using different libraries or frameworks if the current code is functional.
+- Minor performance optimizations unless the change introduces a *significant* and obvious bottleneck.
+- Adding boilerplate (like input validation for simple internal functions) unless its absence *directly* leads to an error identified above based on the diff's context.
+- Suggestions for refactoring code *outside* the direct changes shown in the diff.
+- Comments like `TODO` or similar notes indicating planned work; these are not code errors.
+
+{EXTRA_RULES}
+
+# Output Format:
+
+## If issues are found:
+
+### Issues
+For each hunk with critical issues:
+**<file_path>#L<start>-<end>**
+1. <Concise description of the **critical issue**>
+   - Hint: <Brief explanation of **why** it's a critical issue>
+2. <Description of another **critical issue**>
+   - Hint: <Explanation>
+
+### Suggestions
+For each hunk listed in Issues:
+**<file_path>#L<start>-<end>**
+```suggestion
+<Provide a **complete, corrected code snippet** that should replace the original code block corresponding to the **lines indicated by the hunk header (@@ ... @@)**, typically covering the range L<start>-<end>. Apply the **minimal modifications** to resolve **only** the critical issues identified above. Ensure the resulting snippet is functional and internally consistent. The snippet should represent the final state of the entire code block from the hunk after applying the fix.>

package/src/review-gen/__fixture__/review-gen-fixture.md

@@ -0,0 +1,110 @@
+### parsedCodeMaxTokens rename to parsedCodeChunkMaxTokens (OK) 
+
+#### Diff
+```diff
+### File **src/git/git-core.js**:
+@@ -39,7 +39,7 @@ export const getGitDiffInfo = (branch = undefined) => {
+ 	const commitCount = getGitCommitCount();
+
+ 	const parsedCodeTokens = parsedCodeDiff.reduce((sum, file) => sum + file.tokens, 0);
+-	const parsedCodeMaxTokens = parsedCodeDiff.at(-1)?.tokens || 0;
++	const parsedCodeChunkMaxTokens = parsedCodeDiff.at(-1)?.tokens || 0;
+ 	const programmingLanguages = [...new Set(parsedCodeDiff.map(f => f.programmingLanguage).filter(Boolean))];
+
+ 	return {
+@@ -47,7 +47,7 @@ export const getGitDiffInfo = (branch = undefined) => {
+ 		parsedDiff,
+ 		parsedCodeDiff,
+ 		parsedCodeTokens,
+-		parsedCodeMaxTokens,
++		parsedCodeChunkMaxTokens,
+ 		programmingLanguages,
+ 		commitCount,
+ 	};
+```
+
+#### Expected
+- GOOD
+
+----
+
+### Добавление функции (no issues и suggestions)
+
+#### Diff
+```diff
+--- /dev/null
++++ b/src/utils/logger.ts
+@@ -0,0 +1,3 @@
++function logUserAction(userId: string, action: string): void {
++       console.info(`User ${userId} performed ${action}`);
++}
+```
+
+#### Expected
+- GOOD
+
+----
+
+### Sensitivity data (token)
+
+#### Diff
+```diff
+--- a/src/utils/logger.ts
++++ b/src/utils/logger.ts
+@@ -1,3 +1,3 @@
+-function logUserAction(userId: string, action: string) {
+-       console.info(`User ${userId} performed ${action}`);
++function logUserAction(userId: string, action: string, token: string) {
++       console.info(`User ${userId} performed ${action} (token: ${token})`);
+ }
+```
+
+#### Expected
+- !(console.+token)
+
+----
+
+### JSON.parse
+
+#### Diff
+```diff
+--- /dev/null
++++ b/src/utils/parser.js
+@@ -0,0 +1,3 @@
++function parseUserData(raw) {
++  return JSON.parse(raw);
++}
+```
+
+#### Expected
+- try
+- catch
+- console
+
+----
+
+### Sensitivity data after JSON.parse
+
+#### Diff
+```diff
+--- /dev/null
++++ b/src/parser.js
+@@ -0,0 +1,9 @@
++function parseUser(raw) {
++  try {
++    const user = JSON.parse(raw);
++    console.log(`User data: id=${user.id}, token=${user.token}`);
++    return user;
++  } catch (e) {
++    // TODO: Log parsing error
++    return null;
++  }
++}
+```
+
+#### Expected
+- try
+- catch
+- console
+
+----