🤖 Configure ESLint to only show errors, add manual dead code check (#352)

## Summary

Configures ESLint to treat warnings as errors and adds a manual dead
code checking command. Also removes 506 lines of actual dead code
identified by ts-prune.

## Changes

### ESLint Configuration
- Added `--max-warnings 0` flag to treat all warnings as errors
- Fixed outstanding warnings in `ChatInput.tsx` (missing deps) and
`telemetry/utils.ts` (unsafe any access)

### Dead Code Checking
- Added `make check-deadcode` target for manual dead code detection
using ts-prune
- **Not included in `static-check`** - advisory only, not a hard
requirement
- Filters out test/debug/storybook files and legitimate public API
exports

### Dead Code Removal (506 lines)
- `TypewriterText` component (unused)
- `ToolsTab` component (unused)  
- Duplicate git functions in `git.ts` (implementations exist in
`gitService.ts`)
- Various unused utility functions and types across the codebase

## Why Manual-Only Dead Code Checking?

Automatic dead code checking in CI is too brittle:
- Line-number-based allowlists break on any code change
- Hard to distinguish legitimate public API exports from actual dead
code
- Some exports are intentionally unused (public API surface, type
definitions)
- Dead code is technical debt but not a correctness issue

Manual checking with `make check-deadcode` is still valuable for cleanup
efforts without blocking CI.

_Generated with `cmux`_

Author: ammar-agent

Makefile

@@ -155,6 +155,17 @@ typecheck: node_modules/.installed src/version.ts ## Run TypeScript type checkin
 		"$(TSGO) --noEmit" \
 		"$(TSGO) --noEmit -p tsconfig.main.json"
 
+check-deadcode: node_modules/.installed ## Check for potential dead code (manual only, not in static-check)
+	@echo "Checking for potential dead code with ts-prune..."
+	@echo "(Note: Some unused exports are legitimate - types, public APIs, entry points, etc.)"
+	@echo ""
+	@bun x ts-prune -i '(test|spec|mock|bench|debug|storybook)' \
+		| grep -v "used in module" \
+		| grep -v "src/App.tsx.*default" \
+		| grep -v "src/types/" \
+		| grep -v "telemetry/index.ts" \
+		|| echo "✓ No obvious dead code found"
+
 ## Testing
 test-integration: node_modules/.installed ## Run all tests (unit + integration)
 	@bun test src

scripts/lint.sh

@@ -26,9 +26,9 @@ ESLINT_PATTERN='src/**/*.{ts,tsx}'
 
 if [ "$1" = "--fix" ]; then
   echo "Running bun x eslint with --fix..."
-  bun x eslint --cache "$ESLINT_PATTERN" --fix
+  bun x eslint --cache --max-warnings 0 "$ESLINT_PATTERN" --fix
 else
   echo "Running eslint..."
-  bun x eslint --cache "$ESLINT_PATTERN"
+  bun x eslint --cache --max-warnings 0 "$ESLINT_PATTERN"
   echo "ESLint checks passed!"
 fi

src/components/ChatInput.tsx

@@ -227,21 +227,24 @@ export const ChatInput: React.FC<ChatInputProps> = ({
   // Method to restore text to input (used by compaction cancel)
   const restoreText = useCallback(
     (text: string) => {
-      setInput(text);
+      setInput(() => text);
       focusMessageInput();
     },
-    [focusMessageInput]
+    [focusMessageInput, setInput]
   );
 
   // Method to append text to input (used by Code Review notes)
-  const appendText = useCallback((text: string) => {
-    setInput((prev) => {
-      // Add blank line before if there's existing content
-      const separator = prev.trim() ? "\n\n" : "";
-      return prev + separator + text;
-    });
-    // Don't focus - user wants to keep reviewing
-  }, []);
+  const appendText = useCallback(
+    (text: string) => {
+      setInput((prev) => {
+        // Add blank line before if there's existing content
+        const separator = prev.trim() ? "\n\n" : "";
+        return prev + separator + text;
+      });
+      // Don't focus - user wants to keep reviewing
+    },
+    [setInput]
+  );
 
   // Provide API to parent via callback
   useEffect(() => {

src/components/Messages/MarkdownRenderer.tsx

@@ -32,19 +32,3 @@ export const PlanMarkdownContainer = styled.div`
     color: var(--color-plan-mode-hover);
   }
 `;
-
-interface PlanMarkdownRendererProps {
-  content: string;
-  className?: string;
-}
-
-export const PlanMarkdownRenderer: React.FC<PlanMarkdownRendererProps> = ({
-  content,
-  className,
-}) => {
-  return (
-    <PlanMarkdownContainer className={className}>
-      <MarkdownCore content={content} />
-    </PlanMarkdownContainer>
-  );
-};

src/components/Messages/TypewriterText.tsx

@@ -153,99 +153,6 @@ export async function createWorktree(
   }
 }
 
-export async function removeWorktree(
-  projectPath: string,
-  workspacePath: string,
-  options: { force: boolean } = { force: false }
-): Promise<WorktreeResult> {
-  try {
-    // Remove the worktree (from the main repository context)
-    using proc = execAsync(
-      `git -C "${projectPath}" worktree remove "${workspacePath}" ${options.force ? "--force" : ""}`
-    );
-    await proc.result;
-    return { success: true };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return { success: false, error: message };
-  }
-}
-
-export async function pruneWorktrees(projectPath: string): Promise<WorktreeResult> {
-  try {
-    using proc = execAsync(`git -C "${projectPath}" worktree prune`);
-    await proc.result;
-    return { success: true };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return { success: false, error: message };
-  }
-}
-
-export async function moveWorktree(
-  projectPath: string,
-  oldPath: string,
-  newPath: string
-): Promise<WorktreeResult> {
-  try {
-    // Check if new path already exists
-    if (fs.existsSync(newPath)) {
-      return {
-        success: false,
-        error: `Target path already exists: ${newPath}`,
-      };
-    }
-
-    // Create parent directory for new path if needed
-    const parentDir = path.dirname(newPath);
-    if (!fs.existsSync(parentDir)) {
-      fs.mkdirSync(parentDir, { recursive: true });
-    }
-
-    // Move the worktree using git (from the main repository context)
-    using proc = execAsync(`git -C "${projectPath}" worktree move "${oldPath}" "${newPath}"`);
-    await proc.result;
-    return { success: true, path: newPath };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return { success: false, error: message };
-  }
-}
-
-export async function listWorktrees(projectPath: string): Promise<string[]> {
-  try {
-    using proc = execAsync(`git -C "${projectPath}" worktree list --porcelain`);
-    const { stdout } = await proc.result;
-    const worktrees: string[] = [];
-    const lines = stdout.split("\n");
-
-    for (const line of lines) {
-      if (line.startsWith("worktree ")) {
-        const path = line.slice("worktree ".length);
-        if (path !== projectPath) {
-          // Exclude main worktree
-          worktrees.push(path);
-        }
-      }
-    }
-
-    return worktrees;
-  } catch (error) {
-    console.error("Error listing worktrees:", error);
-    return [];
-  }
-}
-
-export async function isGitRepository(projectPath: string): Promise<boolean> {
-  try {
-    using proc = execAsync(`git -C "${projectPath}" rev-parse --git-dir`);
-    await proc.result;
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 /**
  * Get the main repository path from a worktree path
  * @param worktreePath Path to a git worktree

src/components/RightSidebar/ToolsTab.tsx

@@ -1,4 +1,3 @@
-import * as crypto from "crypto";
 import type * as fs from "fs";
 import * as path from "path";
 import { createPatch } from "diff";
@@ -19,15 +18,7 @@ export const MAX_FILE_SIZE = 1024 * 1024; // 1MB
  * Compute a 6-character hexadecimal lease from file content.
  * The lease changes when file content is modified.
  * Uses a deterministic hash so leases are consistent across processes.
- *
- * @param content - File content as string or Buffer
- * @returns 6-character hexadecimal lease string
  */
-export function leaseFromContent(content: string | Buffer): string {
-  // Use deterministic SHA-256 hash of content so leases are consistent
-  // across processes and restarts
-  return crypto.createHash("sha256").update(content).digest("hex").slice(0, 6);
-}
 
 /**
  * Generate a unified diff between old and new content using jsdiff.

src/git.ts

@@ -9,8 +9,9 @@ import { VERSION } from "../version";
  * Get base telemetry properties included with all events
  */
 export function getBaseTelemetryProperties(): BaseTelemetryProperties {
+  const gitDescribe: string = VERSION.git_describe;
   return {
-    version: VERSION.git_describe,
+    version: gitDescribe,
     platform: window.api?.platform || "unknown",
     electronVersion: window.api?.versions?.electron || "unknown",
   };

src/services/tools/fileCommon.ts

@@ -14,22 +14,6 @@ export type SendMessageError =
   | { type: "invalid_model_string"; message: string }
   | { type: "unknown"; raw: string };
 
-/**
- * Type guard to check if error is an API key error
- */
-export function isApiKeyError(
-  error: SendMessageError
-): error is { type: "api_key_not_found"; provider: string } {
-  return error.type === "api_key_not_found";
-}
-
-/**
- * Type guard to check if error is an unknown error
- */
-export function isUnknownError(error: SendMessageError): error is { type: "unknown"; raw: string } {
-  return error.type === "unknown";
-}
-
 /**
  * Stream error types - categorizes errors during AI streaming
  * Used across backend (StreamManager) and frontend (StreamErrorMessage)