# Rename a symbol across the repo in TensorFlow with Atlas in 2026 > Atlas accurately renames TensorFlow symbols across an entire repository by fusing LSP-driven reference finding with grep for comprehensive coverage and edit for safe, mechanical changes. Atlas provides TensorFlow developers with a precise and safe method to rename functions, classes, or constants across an entire repository, ensuring consistency even in complex Keras 3 models and `tf.data` pipelines. It achieves this by combining the `lsp` tool's authoritative reference finding with `grep` for non-code occurrences, and `edit` for mechanical changes. The process integrates direct with your existing TensorFlow toolchain, including `pytest` for testing, `uv` for package management, and `black` for formatting, all while offering granular control and review at every step. ## Key takeaways - Atlas uses `lsp` for precise, AST-aware symbol renaming in TensorFlow projects. - `grep` ensures all non-code references, like comments and strings, are updated in TensorFlow. - Atlas integrates `pytest` and `black` into the rename workflow for TensorFlow code quality. - Every Atlas tool call and file edit is permission-gated and presented as a diff for approval. - Atlas handles TensorFlow-specific complexities like `tf.function` and `tf.data` pipelines. - File changes are snapshotted as git patches, allowing easy rollback of TensorFlow refactors. ## How Atlas renames TensorFlow symbols accurately across the repo In 2026, Atlas ensures precise symbol renaming in TensorFlow projects by employing a multi-faceted approach that goes beyond simple text replacement. It leverages 3 distinct tools to identify all occurrences, from `tf.function` decorated methods to comments, guaranteeing a complete and correct refactor. Atlas initiates the symbol rename workflow by first utilizing the `lsp` tool's `findReferences` operation. This connects to the language server configured for your Python and TensorFlow environment, providing an authoritative list of all code-level references to the target function, class, or constant based on its Abstract Syntax Tree (AST) declaration. This is crucial for TensorFlow, where `tf.function` graph tracing can obscure direct textual matches, and `tf.data` pipelines might involve complex data flow that a naive search would miss. After gathering these precise code references, Atlas then runs `grep` for the old symbol name. This step is vital for catching occurrences outside the type system, such as strings, comments, documentation within `.py` files, or even configuration entries in `pyproject.toml` that might reference the symbol. This hybrid approach ensures that no reference, whether compiler-visible or human-readable, is overlooked during the rename operation. ## Concrete commands and files involved in a TensorFlow symbol rename Renaming a TensorFlow symbol with Atlas involves a sequence of concrete commands and interactions with specific project files, all managed through the terminal-native agent. The process integrates directly with your `pyproject.toml` defined dependencies and leverages 4 core Atlas tools to execute the refactor. The Atlas workflow for renaming a TensorFlow symbol is highly integrated with your project's structure. After Atlas has indexed your codebase, including Keras model definitions and `tf.data` input pipelines, you would initiate the rename. Atlas uses its `lsp` tool to query the language server for references, which might point to usages within `model.py` or `data_pipeline.py`. The `grep` tool then scans all relevant files for textual matches, including `README.md` or custom configuration files. The mechanical application of changes is handled by the `edit` tool, which uses `replaceAll` for unambiguous matches across files. For instance, if you are renaming `old_optimizer_fn` to `new_optimizer_fn`, `edit` will apply this change across all identified locations. Finally, the `bash` tool is invoked to run your project's tests with `pytest` and format any changed files with `black`, ensuring the codebase remains functional and adheres to style guidelines. A final `grep` confirms zero remaining hits of the old symbol name, providing a robust verification step. ## Review and safety mechanisms for TensorFlow symbol renames with Atlas Atlas prioritizes safety and developer control throughout the symbol renaming process in TensorFlow, offering multiple layers of review and approval. Every tool call is permission-gated, and all proposed changes are presented as a unified diff, ensuring you have 100% visibility before any file is modified. Before Atlas executes any action, it drafts a plan in a read-only plan agent, which you must approve. This initial plan outlines the steps Atlas intends to take, such as using `lsp` to find references or `grep` to search for strings. Every subsequent tool call, whether it is `lsp`, `grep`, `edit`, or `bash`, is permission-gated against allow, ask, and deny rules, providing fine-grained control. When Atlas proposes file edits, it computes a unified diff for every change and surfaces it for your approval. This allows you to review exactly what will change in your TensorFlow code, from a `tf.keras.Model` definition to a `tf.data` pipeline configuration. Atlas also snapshots file changes as git patches, meaning any edits can be easily diffed and rolled back if necessary. This robust review process, combined with Atlas's ability to read git branches and status, ensures that even complex refactors in a TensorFlow codebase are performed with confidence and full transparency. ## Handling TensorFlow-specific challenges during symbol renaming TensorFlow's unique characteristics, such as `tf.function` graph tracing and `tf.data` pipelines, present specific challenges for refactoring tools. Atlas addresses these by leveraging its AST-based indexing and language server integration, ensuring accurate renames even in the most optimized TensorFlow 3 code, where 100% textual matching is insufficient. Renaming symbols in a TensorFlow project requires more than a simple text search and replace, especially with features like `tf.function` which compiles Python functions into a callable TensorFlow graph. A direct text search might miss references within the traced graph or incorrectly match unrelated strings. Atlas overcomes this by building its code index with AST declarations using tree-sitter, allowing it to understand the structural context of symbols. When combined with the `lsp` tool, Atlas can accurately identify references to a function, class, or constant even when it is wrapped by `tf.function` or used within a `tf.data` transformation. This ensures that renaming a function like `_preprocess_image` to `_normalize_image` correctly updates all call sites, including those implicitly handled by TensorFlow's graph execution. Similarly, for `tf.data` pipelines, where operations are often chained, Atlas's semantic understanding prevents erroneous changes and ensures the integrity of your data processing flow. ## Steps 1. Initialize Atlas in your TensorFlow project, ensuring your `pyproject.toml` pins `tensorflow` and `keras`. 2. Ask Atlas to draft a plan for renaming `old_symbol_name` to `new_symbol_name` across the repository. 3. Approve Atlas's plan, allowing it to use the `lsp` tool to find all authoritative code references to `old_symbol_name`. 4. Approve Atlas's use of the `grep` tool to locate non-code occurrences of `old_symbol_name` in comments, strings, and documentation. 5. Approve the `edit` tool's proposed changes, reviewing the unified diffs for each file where `replaceAll` will apply the rename. 6. Approve Atlas to use the `bash` tool to run `pytest` for comprehensive testing and `black` to format any modified TensorFlow files. 7. Approve a final `grep` command to confirm zero remaining instances of `old_symbol_name` in the codebase. 8. Review the final unified diff of all changes and instruct Atlas to stage and create a commit on your behalf. ## FAQ ### How does Atlas handle `tf.function` when renaming symbols? Atlas leverages its AST-based indexing and the `lsp` tool to understand the semantic context of symbols, even when they are wrapped by `tf.function`. This ensures that references within the compiled TensorFlow graph are correctly identified and updated, preventing issues that a simple text-based search might introduce. Atlas's approach guarantees that your `tf.function` decorated code remains functional and consistent after a rename. ### Can Atlas rename symbols in Keras 3 models? Yes, Atlas is fully capable of renaming symbols within Keras 3 models. By reading your Keras model definitions and using the `lsp` tool, Atlas accurately identifies all references to functions, classes, or constants used within your model architecture, custom layers, or training loops. This ensures that your Keras 3 models remain consistent and operational after a refactor. ### What if `grep` finds too many irrelevant matches in TensorFlow code? Atlas's workflow is designed to mitigate this. It first uses `lsp` for authoritative code references, then `grep` for non-code occurrences. When `edit` applies changes, it refuses ambiguous single replacements. You review a unified diff for every proposed change, allowing you to approve only the relevant matches and provide context if needed, preventing unintended modifications in your TensorFlow project. ### How does Atlas ensure my TensorFlow code remains formatted after a rename? Atlas integrates directly with your project's formatter. As part of the rename workflow, Atlas uses the `bash` tool to execute `black` on any files it modifies. This ensures that all changes adhere to your project's formatting standards, maintaining code consistency and readability across your TensorFlow codebase without manual intervention. ### Can I roll back a symbol rename performed by Atlas in TensorFlow? Yes, Atlas provides robust rollback capabilities. It snapshots all file changes as git patches before writing them. This means that every edit is recorded, allowing you to easily diff the changes or roll back to a previous state using standard git commands, providing a safety net for any refactoring operation in your TensorFlow project. ### Does Atlas use local models for indexing my TensorFlow code? Yes, Atlas can build its code index with local Ollama embeddings. This capability ensures that your TensorFlow code remains off third-party servers, enhancing privacy and security. You maintain full control over your codebase and its indexing process, which is particularly important for proprietary TensorFlow projects. ### How does Atlas prevent accidental renames in TensorFlow? Atlas employs several safety mechanisms. It drafts a plan in a read-only agent for your approval, and every tool call is permission-gated. Crucially, for mechanical renames, the `edit` tool refuses ambiguous single replacements, throwing an error unless you add context or explicitly opt into `replaceAll`. All proposed changes are presented as a unified diff for your explicit approval, ensuring no accidental renames occur in your TensorFlow codebase. --- Canonical HTML: https://runatlas.sh/resources/stacks/rename-a-symbol-across-the-repo-in-tensorflow Source of truth: aeo_pages row `/resources/stacks/rename-a-symbol-across-the-repo-in-tensorflow` (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.