You are an expert software engineer. Your task is to review the following
unified code diff and its code changes. You should review the existing
unified code diff and identify any obvious problems with it and propose new
diffs to apply that are compatible with running git apply --3way --check
For specific diff changes and code cleanup, common issues we want to screen for include:
(ERR_LINGERING_CONSOLE_LOG) Definition: Disallow non-descriptive console.log/console.info statements left in code. Example:
// Bad
console.log('FOO');
// Good
console.log('User login successful', { userId });(ERR_NO_CONSTANTS) Definition: Hard-coded constants must be extracted to a config or constants file. Example:
// Bad
const API_URL = 'https://api.example.com/v1
';
// Good
const API_URL = require('../config').API_URL;(ERR_REMOVE_COMMENTED_CODE) Definition: Remove commented-out code blocks that are no longer active. Example:
// Bad
// const oldMethod = () => doSomething();
// oldMethod();
// Good
newMethod();(ERR_LOGIC) Definition: Flag obvious logical mistakes or unreachable code. Example:
// Bad
if (isAdmin = true) { // assignment instead of comparison
grantAccess();
}
// Good
if (isAdmin === true) {
grantAccess();
}(ERR_LINE_LENGTH) Definition: Lines must not exceed 80 characters (except unavoidable literals). Example:
// Bad
const msg = "This is a very long line of text that exceeds the recommended eighty character limit...";
// Good
const msg =
"This is a very long line of text that exceeds the recommended " +
"eighty character limit...";(ERR_INLINE_DEPENDENCIES) Definition: All imports/requires must be at the top of the file unless async dynamic loading is required. Example:
// Bad
function handler() {
const fs = require('fs'); // inline require
return fs.readFileSync('file.txt');
}
// Good
const fs = require('fs');
function handler() {
return fs.readFileSync('file.txt');
}(ERR_AWAIT_USED_WITHOUT_ASYNC) Definition: Ensure await is only used inside async functions. Example:
// Bad
function fetchData() {
await getData();
}
// Good
async function fetchData() {
await getData();
}(ERR_NO_EMPTY_CATCH_BLOCK) Definition: Catch blocks must not be empty; they must rethrow or log meaningfully. Example:
// Bad
try {
riskyOperation();
} catch (e) { }
// Good
try {
riskyOperation();
} catch (e) {
console.warn('Operation failed', e);
throw e;
}(ERR_NO_UNUSED_VARS) Definition: Remove variables that are declared but never used. Example:
// Bad
const unused = 42;
doSomething();
// Good
doSomething();(WARN_PREFER_SINGLE_QUOTE) Definition: Prefer single quotes for strings, or backticks if variable substitution is required. Example:
// Bad
const msg = "Hello world";
// Good
const msg = 'Hello world';
const greeting = `Hello ${user}`;(WARN_PREFER__DIRNAME) Definition: Prefer usage of __dirname in require statements instead of relative ./ paths. Example:
// Bad
const config = require('./config/settings.js');
// Good
const config = require(__dirname + '/config/settings.js');(WARN_NO_EXPOSED_STACK_TRACES) Definition: Do not expose raw error stack traces unless gated behind a microhost.verbose check. Example:
// Bad
console.error(err.stack);
// Good
if (microhost.verbose) {
console.error(err.stack);
}(ERR_NO_PLAIN_TODO) Definition: Forbid lingering // TODO: or // FIXME: comments without an issue reference or meaningful description. Example:
// Bad
// TODO: fix this
// Good
// TODO[#123]: handle null userId values gracefully(WARN_NO_MAGIC_NUMBERS) Definition: Avoid unexplained numeric literals; extract them into named constants or config. Example:
// Bad
if (retryCount > 7) { ... }
// Good
const MAX_RETRIES = 7;
if (retryCount > MAX_RETRIES) { ... }(ERR_NO_DUPLICATE_IMPORTS) Definition: Consolidate duplicate imports from the same module into a single import statement. Example:
// Bad
import { readFile } from 'fs';
import { writeFile } from 'fs';
// Good
import { readFile, writeFile } from 'fs';(WARN_NO_NESTED_TRY) Definition: Discourage deeply nested try/catch blocks; refactor into helper functions where possible. Example:
// Bad
try {
try {
riskyOp();
} catch (e) {
handleInner(e);
}
} catch (e) {
handleOuter(e);
}
// Good
function safeOp() {
try {
riskyOp();
} catch (e) {
handleInner(e);
}
}
try {
safeOp();
} catch (e) {
handleOuter(e);
}(ERR_NO_IMPLICIT_GLOBALS) Definition: Forbid assigning to undeclared variables, which implicitly creates globals. Example:
// Bad
foo = 123;
// Good
let foo = 123;(ERR_NO_MUTABLE_CONST_OBJ) Definition: Do not mutate const object properties directly; freeze or encapsulate them instead. Example:
// Bad
const config = {};
config.port = 8080;
// Good
const config = Object.freeze({ port: 8080 });(ERR_NO_PROCESS_EXIT) Definition: Forbid process.exit() in libraries or runtime code; allowed only in CLI entrypoints. Example:
// Bad
if (error) process.exit(1);
// Good
throw new Error('Fatal initialization error');(ERR_NO_HTTP) Definition: Forbid usage of http:// URLs in production code where https:// is available. Example:
// Bad
fetch('http://api.example.com
');
// Good
fetch('https://api.example.com
');(WARN_PREFER_OPTIONAL_CHAINING) Definition: Prefer optional chaining (?.) over verbose defensive && checks. Example:
// Bad
if (user && user.profile && user.profile.name) { ... }
// Good
if (user?.profile?.name) { ... }(WARN_NO_DEEP_OBJECT_MERGE) Definition: Avoid blindly spreading nested objects; use safe merge utilities or explicit assignment. Example:
// Bad
const merged = { ...defaults, ...overrides };
// Good
const merged = deepMerge(defaults, overrides);(WARN_LIMIT_CHAINING) Definition: Long method chains (3 or more calls) should be broken into intermediate steps for readability. Example:
// Bad
const result = arr.filter(f1).map(f2).reduce(f3).sort(f4);
// Good
const filtered = arr.filter(f1);
const mapped = filtered.map(f2);
const reduced = mapped.reduce(f3);
const result = reduced.sort(f4);(ERR_DEEP_NESTING) Definition: Disallow nesting beyond 3 levels of if/else/try/catch; refactor into separate functions. Example:
// Bad
if (a) {
if (b) {
if (c) {
doThing();
}
}
}
// Good
if (a && b && c) {
doThing();
}(WARN_COMPLEX_CONDITION) Definition: Boolean expressions with more than 3 operators must be split into intermediate variables. Example:
// Bad
if (a && b || c && !d && e) { ... }
// Good
const validState = a && b;
const exception = c && !d && e;
if (validState || exception) { ... }(ERR_LINE_LENGTH) Definition: Lines must not exceed 80 characters (except unavoidable literals). Example:
// Bad
const msg = "This is a very long line of text that exceeds the recommended eighty character limit...";
// Good
const msg =
"This is a very long line of text that exceeds the recommended " +
"eighty character limit...";(WARN_DESCRIPTIVE_NAMES) Definition: Variable names should be descriptive; avoid vague names like data or arr. Example:
// Bad
const data = get();
// Good
const userProfiles = getUserProfiles();(WARN_MULTIPLE_RETURN_TYPES) Definition: Functions must not return mixed types (e.g., sometimes a string, sometimes a number). Example:
// Bad
function getValue(flag) {
if (flag) return "123";
return 123;
}
// Good
function getValue(flag) {
if (flag) return "123";
return "456";
}(ERR_NO_DEEPLY_NESTED_TERNARIES) Definition: Forbid multi-layer nested ternary operators; use if/else or helper functions. Example:
// Bad
const msg = isAdmin ? (isSuper ? "super admin" : "admin") : "guest";
// Good
let msg;
if (isAdmin) {
msg = isSuper ? "super admin" : "admin";
} else {
msg = "guest";
}(NOTICE_FN_HAS_SIDE_EFFECTS) Definition: Helper functions should be idempotent and avoid hidden side effects. Example:
// Bad
function addUser(user) {
users.push(user); // modifies external array
}
// Good
function addUser(users, user) {
return [...users, user];
}(WARN_NO_INLINE_OBJECT_LITERALS) Definition: Avoid placing complex object literals inline in function calls; extract them into variables. Example:
// Bad
saveUser({ name: "Alice", role: "admin", created: Date.now() });
// Good
const newUser = { name: "Alice", role: "admin", created: Date.now() };
saveUser(newUser);(WARN_LIMIT_INLINE_CONDITIONALS) Definition: Avoid inline conditional expressions (condition && doThing()); prefer explicit if statements. Example:
// Bad
isReady && startProcess();
// Good
if (isReady) {
startProcess();
}(ERR_FUNCTION_ALPHABETIZATION) Definition: Functions in a file or within a class should be alphabetized for easier scanning. Example:
// Bad
function zebra() {}
function alpha() {}
// Good
function alpha() {}
function zebra() {}(WARN_IMPORT_OR_REQUIRE_ALPHABETIZATION) Definition: Import and require statements should be alphabetized where possible, without breaking dependency chains or load order. Example:
// Bad
const path = require('path');
const fs = require('fs');
// Good
const fs = require('fs');
const path = require('path');For specific diff changes and code cleanup, you should output a unified diff format with suggested changes, using these rules:
- Output a unified diff
- Use 3+ lines of context per hunk.
- You must start all unified diff blocks using
and terminate using - You must escape all backticks in a unified diff with a backslash
- Preserve file modes/renames if relevant.
- If creating a new file, use /dev/null in the --- header.
- A patch that applies cleanly with
git apply --3way --checkcovering all changes, using this exact form:
Example revision remark:
Description: Context: You produced a const variable declaration without a variable and this will throw a syntax error
--- a/<path>
+++ b/<path>
@@ -<start>,<len> +<start>,<len> @@
<context/removed lines prefixed with ' ' or '-'>
<added lines prefixed with '+'>
Here are the code changes to review:
Here are the original source files: