feat: Enforce explicit type coercion and empty blocks rules

Add no-implicit-coercion and no-empty rules to improve code quality across the codebase:

- no-implicit-coercion: Enforces explicit, context-aware type comparisons to address
  ambiguity issues with falsy values and improve code clarity
- no-empty: Requires all code blocks to have meaningful content, preventing silent
  error suppression and improving code readability

This change includes:
- Adding detailed documentation in .roo/rules/eslint-no-implicit-coercion.md with
  specific guidance on proper type checking patterns
- Adding documentation for no-unused-vars rule enforcement in .roo/rules/eslint-no-unused-vars.md
- Explicitly adding both rules as "error" in both root and webview-ui configs
- Setting --max-warnings=0 in lint scripts to ensure strict enforcement

These changes ensure developers use explicit type checks and properly document
empty blocks, particularly important for distinguishing between null, undefined,
and empty strings in conditional logic.

Fixes: #3692
Signed-off-by: Eric Wheeler <[email protected]>

Author: Eric Wheeler

.roo/rules/eslint-no-empty.md

@@ -0,0 +1,38 @@
+# Handling ESLint `no-empty` Rule
+
+Empty block statements (`{}`) are disallowed. All blocks MUST include a logging statement (e.g., `console.error`, `console.warn`, `console.log`, `console.debug`) to make their purpose explicit.
+
+This applies to `if`, `else`, `while`, `for`, `switch` cases, `try...catch` blocks, and function bodies.
+
+### Examples:
+
+```javascript
+// Correct: Logging in blocks
+if (condition) {
+	console.warn("Condition met, no specific action.")
+}
+
+try {
+	criticalOperation()
+} catch (error) {
+	// For unexpected errors:
+	console.error("Unexpected error in criticalOperation:", error)
+}
+
+function foo() {
+	console.log("foo called, no operation.")
+}
+```
+
+### Special Considerations:
+
+- **Intentional Error Suppression**: Use `console.debug` in `catch` blocks if an error is intentionally suppressed.
+    ```javascript
+    try {
+    	operationThatMightBenignlyFail()
+    } catch (error) {
+    	console.debug("Benign failure in operation, suppressed:", error)
+    }
+    ```
+- **Constructors**: Empty constructors should log, preferably with `console.debug`.
+- **Comments**: Comments can supplement logs but do not replace the logging requirement.

.roo/rules/eslint-no-implicit-coercion.md

@@ -0,0 +1,79 @@
+# Handling ESLint `no-implicit-coercion` Errors
+
+When ESLint's `no-implicit-coercion` rule flags an error, a value is being implicitly converted to a boolean, number, or string. While ESLint might suggest `Boolean(value)`, `Number(value)`, or `String(value)`, this project requires a different approach for boolean coercions.
+
+## Guideline: Explicit, Context-Aware Comparisons
+
+For boolean coercions (e.g., in `if` statements or ternaries), MUST NOT use `Boolean(value)`. Instead, extend conditional expressions to explicitly compare against the specific data type and value expected for that implementation context.
+
+YOU MUST NEVER replace `if (myVar)` with `if (Boolean(myVar))` or `if (!!myVar)` with `if (Boolean(myVar))`.
+
+This rule's purpose is to encourage a thoughtful evaluation of what "truthy" or "falsy" means for the specific variable and logic.
+
+### Examples:
+
+## Incorrect (MUST NOT DO THIS):
+
+```typescript
+// Implicit coercion (flagged by ESLint)
+if (someStringOrNull) {
+	// ...
+}
+
+// Explicit coercion using Boolean() (not the preferred fix here)
+if (Boolean(someStringOrNull)) {
+	// ...
+}
+```
+
+## Correct (Preferred Approach):
+
+- Checking for a non-empty string:
+
+    ```typescript
+    if (typeof someStringOrNull === "string" && someStringOrNull != "") {
+    	// ...
+    }
+    // Or, if an empty string is valid but null/undefined is not:
+    if (typeof someStringOrNull === "string") {
+    	// ...
+    }
+    ```
+
+- Checking against `null` or `undefined`:
+
+    ```typescript
+    if (someValue !== null && someValue !== undefined) {
+    	// ...
+    }
+    // Shorter (catches both null and undefined, mind other falsy values):
+    if (someValue != null) {
+    	// ...
+    }
+    ```
+
+- Checking if a variable is assigned (not `undefined`):
+
+    ```typescript
+    if (someOptionalValue !== undefined) {
+    	// ...
+    }
+    ```
+
+- Checking if an array has elements:
+    ```typescript
+    if (Array.isArray(myArray) && myArray.length > 0) {
+    	// ...
+    }
+    ```
+
+### Rationale:
+
+Explicitly comparing types and values:
+
+1.  Clarifies the code's intent.
+2.  Reduces ambiguity regarding how falsy values (`null`, `undefined`, `0`, `""`, `NaN`) are handled.
+3.  Helps avoid bugs from overly general truthiness checks when specific conditions were needed.
+4.  Be careful of regular expression evaluations. For example, `/foo (.*)bar/` will legitimately match an empty string, or it may not match at all. You MUST differentiate between `match === undefined` vs `typeof match === 'string' && match != ""` because falsy evaluation MUST NOT BE USED because it is usually invalid and certainly imprecise.
+
+Always consider the context: What does "truthy" or "falsy" mean for this variable in this logic? Write conditions reflecting that precise meaning.

.roo/rules/eslint-no-unused-vars.md

@@ -0,0 +1,63 @@
+# Handling `@typescript-eslint/no-unused-vars`
+
+If `@typescript-eslint/no-unused-vars` flags an error, a declaration is unused.
+
+## Guideline: Omit or Delete
+
+Unused declarations MUST be omitted or deleted.
+
+CRITICAL: Unused declarations MUST NOT be "fixed" by prefixing with an underscore (`_`). This is disallowed. Remove dead code, do not silence the linter.
+
+### Examples:
+
+#### Incorrect:
+
+```typescript
+// error: 'unusedVar' is defined but never used.
+function example(usedParam: string, unusedParam: number): void {
+	console.log(usedParam)
+	// Incorrect fix:
+	// const _unusedVar = 10;
+}
+```
+
+```typescript
+// error: 'error' is defined but never used.
+try {
+	// ...
+} catch (error) {
+	// 'error' is unused
+	// Incorrect fix:
+	// } catch (_error) {
+	console.error("An operation failed.")
+}
+```
+
+#### Correct:
+
+```typescript
+// 'unusedParam' removed if not needed by an interface/override.
+function example(usedParam: string): void {
+	// 'unusedParam' removed
+	console.log(usedParam)
+	// 'unusedVar' is completely removed.
+}
+```
+
+```typescript
+// 'error' variable is removed from the catch block if not used.
+try {
+	// ...
+} catch {
+	// 'error' variable omitted entirely
+	console.error("An operation failed.")
+}
+```
+
+### Rationale:
+
+- Clarity: Removing unused code improves readability.
+- Bugs: Unused variables can indicate errors.
+- No Workarounds: Prefixing with `_` hides issues.
+
+Code should be actively used.

src/eslint.config.mjs

@@ -8,9 +8,11 @@ export default [
 			// TODO: These should be fixed and the rules re-enabled.
 			"no-regex-spaces": "off",
 			"no-useless-escape": "off",
-			"no-empty": "off",
 			"prefer-const": "off",
 
+			"no-empty": "error",
+			"no-implicit-coercion": "error",
+
 			"@typescript-eslint/no-unused-vars": "off",
 			"@typescript-eslint/no-explicit-any": "off",
 			"@typescript-eslint/no-require-imports": "off",

webview-ui/eslint.config.mjs

@@ -18,6 +18,8 @@ export default [
 			"@typescript-eslint/no-explicit-any": "off",
 			"react/prop-types": "off",
 			"react/display-name": "off",
+			"no-empty": "error",
+			"no-implicit-coercion": "error",
 		},
 	},
 	{