# Rename a symbol across the repo in Deno with Atlas in 2026 > Atlas precisely renames symbols across your Deno project by combining LSP-driven reference finding with `grep` for comprehensive updates, ensuring your `deno test` suite passes. To rename a function, class, or constant across your Deno repository, Atlas leverages Deno's language server protocol (LSP) for accurate reference finding, then uses `grep` to catch non-code occurrences, and applies changes with its `edit` tool, followed by verification with `deno test` and `deno fmt`. This comprehensive approach ensures a complete and safe refactoring process for Deno developers. ## Key takeaways - Atlas uses Deno's LSP for precise, type-aware symbol renames across your codebase. - `grep` catches non-code references in Deno comments, strings, and documentation for comprehensive updates. - Atlas `edit` applies renames safely, preventing ambiguous changes and requiring explicit `replaceAll` for multiple matches. - Verify Deno refactors with `deno test`, `deno check`, and `deno fmt` via Atlas `bash` for functional and style integrity. - Atlas provides unified diffs and permission prompts for Deno code changes, ensuring full developer control and safety. ## How Atlas renames Deno symbols using LSP Atlas renames Deno symbols with high precision by first querying the Deno language server via the `lsp` tool's `findReferences` operation. This ensures that in 2026, every true code reference to a function, class, or constant is identified, avoiding the pitfalls of naive text replacement and maintaining code integrity. When you initiate a symbol rename in a Deno project, Atlas begins by invoking the `lsp` tool. This tool connects to Deno's built-in language server, which understands the project's Abstract Syntax Tree (AST) declarations, import maps, and module graph. By calling the `findReferences` operation, Atlas obtains an authoritative list of all code locations where the target function, class, or constant is used. This includes imports, exports, function calls, variable assignments, and type annotations across all `.ts`, `.tsx`, `.js`, and `.jsx` files. This method is superior to simple text search because it respects scope, type, and module boundaries, ensuring that only the intended symbol is renamed and preventing accidental modifications to unrelated but similarly named identifiers. ## Catching Deno string and comment references with Atlas grep Beyond code references, Atlas uses its `grep` tool to locate instances of the old symbol name within strings, comments, and documentation across your Deno project. This crucial step ensures that in 2026, even non-executable occurrences are updated, providing a complete refactor that a compiler or LSP alone would miss. While Deno's language server provides precise code references, a comprehensive rename requires updating all mentions of the symbol, including those outside the type system. Atlas addresses this by running its `grep` tool for the old symbol name. This catches occurrences in places like JSDoc comments, inline code comments, string literals (e.g., error messages, UI labels), and even configuration files like `deno.jsonc` or markdown documentation. For example, if you rename a function `fetchUserData` to `retrieveUserData`, `grep` will find and allow you to update a comment like `// Fetches user data from API` or a string `console.log('Fetching user data...');`. This ensures that your Deno codebase remains consistent and readable after the refactor, providing a 360-degree update. ## Applying mechanical renames in Deno files with Atlas edit Atlas applies the mechanical renames to your Deno files using its `edit` tool with the `replaceAll` operation. This ensures that all identified occurrences are updated consistently. The `edit` tool is designed to refuse ambiguous single replacements, preventing silent corruption in your 2026 Deno codebase. Once Atlas has identified all code references via LSP and non-code references via `grep`, it uses its `edit` tool to perform the actual text replacements. For a symbol rename, the `replaceAll` operation is typically used, ensuring every identified instance of the old name is replaced with the new one. A key safety feature of the `edit` tool is its strictness: if you attempt a single replacement and it finds multiple matches for the `oldString` within a file, it will throw an error like 'Found multiple matches for oldString' rather than making an ambiguous change. This forces explicit action, either by providing more context to narrow the match or by confirming the intent to `replaceAll`. This prevents unintended modifications and ensures that your Deno project's source files, including those managed by `deno fmt`, are updated precisely as intended. ## Verifying Deno renames with `deno test` and `deno fmt` After applying renames, Atlas verifies the integrity of your Deno project by running `deno test` and `deno fmt` via the `bash` tool. This ensures that the refactoring has not introduced regressions and that the code adheres to your project's formatting standards, a critical step in any 2026 development workflow. A successful rename isn't just about changing text; it's about maintaining functionality and code quality. Atlas integrates directly with Deno's robust toolchain for verification. After applying all changes, Atlas uses its `bash` tool to execute `deno test`, running your project's test suite to catch any functional regressions introduced by the rename. It also runs `deno check` to ensure type correctness and `deno fmt` to automatically reformat any affected files according to your project's `deno.json` or `deno.jsonc` configuration. Finally, Atlas performs one more `grep` for the old symbol name across the entire repository to definitively prove that zero instances of the old name remain, providing a high degree of confidence in the refactoring's completeness. ## Atlas safety and review for Deno refactoring Atlas prioritizes safety during Deno refactoring by drafting a read-only plan, asking for approval before execution, and presenting a unified diff for every file edit. This multi-stage approval process ensures that in 2026, you maintain full control over changes, preventing unintended modifications to your `deno.jsonc` or source files. Every action Atlas takes during a Deno symbol rename is permission-gated. Before any changes are made, Atlas operates in a read-only 'plan agent' phase, where it drafts a detailed plan of proposed modifications. This plan is presented to you for review and approval. Once approved, it switches to a 'build agent' to execute the plan. Crucially, every tool call (like `lsp`, `grep`, `edit`, `bash`) is subject to `allow`, `ask`, or `deny` rules, giving you granular control. For every file edit, Atlas computes a unified diff, clearly showing what was changed, added, or removed. This diff is surfaced for your final approval before Atlas writes any changes to disk. Atlas also integrates with Git, allowing it to read branches, status, and diffs, and can even stage and create commits on your behalf, providing a robust rollback mechanism through git patches if needed. ## Setting up Atlas for Deno projects with `deno.json` To effectively rename symbols in your Deno project, ensure Atlas is run within a directory containing a `deno.json` or `deno.jsonc` file. Atlas automatically reads your import map, JSR and npm specifiers, and defined tasks, providing a robust environment for refactoring in 2026. Atlas is designed to direct integrate with Deno projects. The primary setup involves simply running Atlas within a project directory that contains a `deno.json` or `deno.jsonc` configuration file. Atlas automatically detects and parses this file, understanding your project's structure, including its import map, JSR and npm package specifiers, and any custom tasks defined. This allows Atlas to accurately resolve module paths for LSP operations and understand your project's dependencies. For instance, Atlas can assist in adding new dependencies using `deno add jsr:@std/...` rather than requiring manual `import_map.json` edits. This deep understanding of the Deno ecosystem ensures that Atlas's refactoring operations are context-aware and respect your project's specific configurations and module resolution rules. ## Steps 1. Use the Atlas `lsp` tool's `findReferences` operation on the symbol to get the authoritative callsite list from Deno's language server. 2. Run Atlas `grep` for the old symbol name to catch occurrences outside the Deno type system: strings, comments, documentation, and config files like `deno.jsonc`. 3. Apply the mechanical renames across Deno files with Atlas `edit` using `replaceAll` where the match is unambiguous per file. 4. Compile your Deno project with `deno check` via Atlas `bash` to catch any type errors introduced by the rename. 5. Run Deno tests with `deno test` using Atlas `bash` to verify that the refactoring has not introduced functional regressions. 6. Format your Deno code with `deno fmt` via Atlas `bash` to ensure all affected files adhere to Deno's style guidelines. 7. Perform a final `grep` for the old symbol name across your Deno codebase to prove zero remaining hits. 8. Review the unified diffs presented by Atlas and approve the changes before they are written to your Deno project files. ## FAQ ### How does Atlas ensure accurate renames in Deno? Atlas uses the `lsp` tool to query Deno's language server, obtaining an authoritative list of references for functions, classes, or constants, ensuring type-aware precision across your Deno project. ### Can Atlas rename symbols in Deno comments or strings? Yes, Atlas runs its `grep` tool to find and update occurrences of the old symbol name within comments, string literals, documentation, and configuration files like `deno.jsonc` in your Deno project. ### What Deno tools does Atlas use for verification? Atlas uses its `bash` tool to execute `deno test` for functional verification, `deno check` for type checking, and `deno fmt` for code formatting after a rename in your Deno project. ### How does Atlas prevent accidental changes during a Deno rename? Atlas drafts a read-only plan, requires explicit approval before executing changes, and presents a unified diff for every file edit, ensuring you review all modifications to your Deno code. ### Does Atlas support Deno's `deno.json` and import maps? Yes, Atlas reads your `deno.json` or `deno.jsonc` file, including import maps, JSR, and npm specifiers, to understand your Deno project's structure and dependencies for accurate refactoring. ### What if Atlas `edit` finds multiple matches for a Deno symbol? The Atlas `edit` tool will throw an error like 'Found multiple matches for oldString' if a single replacement is ambiguous, requiring you to add context or explicitly opt into `replaceAll` for that Deno file. ### Can Atlas manage Deno dependencies during refactoring? While focused on renaming, Atlas can also add dependencies using `deno add jsr:@std/...` and manage tasks defined in your `deno.json`, integrating with your Deno dependency workflow. --- Canonical HTML: https://runatlas.sh/resources/stacks/rename-a-symbol-across-the-repo-in-deno Source of truth: aeo_pages row `/resources/stacks/rename-a-symbol-across-the-repo-in-deno` (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.