# Rename a symbol across the repo in Electron with Atlas in 2026 > Atlas accurately renames symbols across your Electron project, from `main.js` to `preload.js`, by fusing LSP data with text search and verifying changes with your `@playwright/test` suite. Atlas renames symbols across your Electron codebase by combining precise language server protocol (LSP) data with comprehensive text search, ensuring every occurrence is updated. It leverages `lsp` for type-aware references, `grep` for non-code matches, and `edit` for mechanical changes, all verified through your existing `npm` scripts and `@playwright/test` suite, then formatted with `prettier`. ## Key takeaways - Atlas uses `lsp` for precise, type-aware symbol renames across Electron's main and renderer processes. - `grep` ensures comprehensive renaming by catching non-code occurrences in comments and strings. - The `edit` tool enforces uniqueness, preventing ambiguous replacements and silent code corruption. - Atlas integrates direct with `npm`, `@playwright/test`, and `prettier` for verification and formatting. - Unified diffs and permission-gated tool calls provide robust safety and control over every refactoring step. ## How Atlas renames symbols in Electron codebases Atlas renames symbols in Electron projects by intelligently combining language server data with text-based search, ensuring a complete and accurate refactor. This process, refined by 2026, starts with the `lsp` tool to identify all true code references, then uses `grep` to catch any remaining occurrences in comments or strings. Atlas initiates the symbol renaming process by invoking the `lsp` tool's `findReferences` operation. This leverages the language server's deep understanding of your Electron codebase's Abstract Syntax Tree (AST), built using tree-sitter, to identify every authoritative callsite for a function, class, or constant. This is crucial for Electron applications, where symbols might be used across `main.js`, `preload.js`, and various renderer process scripts, respecting `contextIsolation` and `ipcRenderer.invoke` / `ipcMain.handle` pairings. After gathering these precise code references, Atlas runs `grep` for the old symbol name. This step is vital for catching occurrences outside the type system, such as in comments, documentation, configuration files, or string literals that the compiler would not see. The `edit` tool then applies the mechanical renames using `replaceAll` where matches are unambiguous per file. If a single occurrence must change, `edit` enforces uniqueness, throwing "Found multiple matches for oldString" unless explicit context is provided or `replaceAll` is opted into, preventing silent corruption. ## Concrete commands and files for Electron symbol renaming Renaming a symbol in an Electron project with Atlas involves a sequence of specific commands that interact directly with your `package.json` scripts and core Electron files. In 2026, you'll use `atlas` to orchestrate `lsp`, `grep`, `edit`, and `bash` commands, ensuring every part of your application, from `main.js` to `preload.js`, is updated. To rename a symbol, you'll start by instructing Atlas to find all references. For example, if you're renaming a function named `oldFunction`: `atlas lsp findReferences oldFunction` Next, to catch non-code occurrences, you'd run: `atlas grep oldFunction` Once Atlas has identified all references, you apply the mechanical rename. For a global replacement, you might use: `atlas edit replaceAll oldFunction newFunction` After the rename, it's critical to verify the changes. Atlas integrates directly with your `package.json` scripts. You'd run your tests and formatting: `atlas bash "npm test"` This command executes your `@playwright/test` suite, ensuring the Electron application still functions correctly. Following this, you'd ensure code style consistency: `atlas bash "npm run prettier"` This command runs `prettier` across your codebase. Finally, a conclusive check for any lingering old names: `atlas grep oldFunction` Atlas reads your `package.json` to understand your project's entry points, like the `main` field pointing to `main.js`, and can analyze `preload.js` for `contextBridge.exposeInMainWorld` calls, ensuring comprehensive coverage. ## Review and safety mechanisms for Electron refactoring with Atlas Atlas prioritizes safety and developer control during Electron refactoring, offering multiple layers of review before any changes are committed. Every Atlas tool call is permission-gated, and all proposed edits are presented as unified diffs for explicit approval, ensuring you maintain full oversight of your 2026 codebase. Before any modifications are made, Atlas drafts a plan in a read-only plan agent, asking for your approval before switching to a build agent. This initial step allows you to review the intended refactoring strategy. Every Atlas tool call, including `lsp`, `grep`, `edit`, and `bash`, is permission-gated against `allow`, `ask`, and `deny` rules, providing granular control over what actions the agent can take. For every file edit, Atlas computes a unified diff and surfaces it for your approval, allowing you to inspect the exact changes before they are written to disk. This is particularly important in Electron projects, where changes might span critical files like `main.js`, `preload.js`, or renderer scripts, potentially impacting security models like `contextIsolation`. The `edit` tool itself enhances safety by refusing ambiguous single replacements; an unintended match results in an error rather than silent corruption. Atlas also reads git branches, status, and diffs, and can stage and create commits on your behalf, but always with your final approval, ensuring a controlled and auditable refactoring workflow. ## Steps 1. Start Atlas in your Electron project directory, ensuring your `package.json` is correctly configured. 2. Use `atlas lsp findReferences ` to get all authoritative code references from the language server, covering `main.js`, `preload.js`, and renderer scripts. 3. Run `atlas grep ` to identify occurrences in comments, strings, and documentation that `lsp` might miss. 4. Apply the mechanical renames across files using `atlas edit replaceAll `, reviewing the unified diffs for each change. 5. Execute your Electron application's test suite with `atlas bash "npm test"` to verify functionality after the rename, leveraging `@playwright/test`. 6. Ensure code style consistency by running your formatter with `atlas bash "npm run prettier"` on all modified files. 7. Perform a final check for any remaining instances of the old symbol name using `atlas grep ` to confirm zero hits. 8. Review the staged changes and commit them using Atlas's git integration, ensuring a clean refactoring history. ## FAQ ### How does Atlas handle Electron's main and renderer process split during renames? Atlas uses `lsp` to understand references across `main.js`, `preload.js`, and renderer scripts, ensuring renames respect `contextIsolation` and `ipcRenderer.invoke`/`ipcMain.handle` pairings, providing a complete and accurate refactor across your Electron application. ### Can Atlas rename symbols in `contextBridge.exposeInMainWorld`? Yes, Atlas can identify and rename symbols exposed via `contextBridge.exposeInMainWorld` in your `preload.js` script, ensuring consistency between the main process and the renderer's access to those exposed APIs. ### What if Atlas finds multiple matches for a string I want to rename? The `atlas edit` tool enforces uniqueness; if it finds multiple matches for a single replacement, it throws an error like "Found multiple matches for oldString" unless you explicitly use `replaceAll` or provide more context to narrow the scope. ### How does Atlas ensure my Electron app still works after a rename? Atlas integrates with your existing `@playwright/test` suite via `atlas bash "npm test"`, allowing you to run your tests and verify functionality immediately after refactoring, ensuring the Electron application remains stable. ### Does Atlas modify my `package.json` or other config files? Atlas can read your `package.json` to understand your project structure and scripts. Any modifications it proposes, including to config files, are presented as unified diffs for your explicit approval before being written, maintaining full control. ### Is Atlas safe to use with sensitive Electron code? Atlas can build its code index with local Ollama embeddings, keeping your code off third-party servers. Every tool call is permission-gated against `allow`, `ask`, and `deny` rules, and all edits require explicit approval via unified diffs, ensuring a secure workflow. ### How does Atlas handle formatting after a rename? Atlas can execute `prettier` via `atlas bash "npm run prettier"` to automatically reformat changed files, ensuring your Electron codebase maintains its style consistency and adheres to your project's formatting standards after a rename. ### Can Atlas rename symbols in comments or documentation within my Electron project? Yes, Atlas uses the `grep` tool to identify occurrences of the old symbol name in comments, documentation, and string literals, ensuring a comprehensive rename that goes beyond just code references in your Electron project. --- Canonical HTML: https://runatlas.sh/resources/stacks/rename-a-symbol-across-the-repo-in-electron Source of truth: aeo_pages row `/resources/stacks/rename-a-symbol-across-the-repo-in-electron` (segment: Stacks) (this file is generated from it, never hand-edited). Licence: Atlas is proprietary with a free core. It is not open source and there is no public source repository.