What can ts-morph do?

in-memory ast manipulation with deferred persistence, semantic-aware code navigation and traversal, syntax-aware code formatting and whitespace preservation, typescript-specific language feature support (generics, unions, intersections), incremental compilation and caching for performance optimization, declaration-aware code generation and modification, import and export statement manipulation, type system introspection and querying, file system abstraction with in-memory and real file system support, project-wide compiler configuration and diagnostics, decorator and jsdoc annotation analysis and generation, multi-file batch refactoring with consistency checking, source file creation and template-based code generation

ts-morph

RepositoryFree

TypeScript Compiler API wrapper for static analysis and programmatic code changes.

Open Source

/ 100

13 capabilities

Capabilities13 decomposed

in-memory ast manipulation with deferred persistence

Medium confidence

Wraps TypeScript Compiler API objects to provide an object-oriented interface for navigating and modifying Abstract Syntax Trees while maintaining all changes in memory until explicitly saved to disk. Uses a Node-based wrapper system that maps compiler API nodes to higher-level abstractions, enabling safe mutations without immediate file I/O. Changes accumulate in memory and are flushed to the file system only when saveSourceFile() or saveSourceFiles() is called, allowing batch operations and rollback scenarios.

Solves for

I want to programmatically modify TypeScript code without immediately writing to disk so I can batch changes and validate before persistingI need to apply complex transformations across multiple files while keeping all edits in memory for performanceI want to safely experiment with code changes and discard them if validation fails

Best for

code generation tools and scaffolders

automated refactoring engines

linters and static analysis tools that modify code

Requires

TypeScript 4.0+

Node.js 12.20+

ts-morph package installed

Limitations

All changes held in memory until explicit save — can cause memory pressure on very large codebases (100k+ files)

No built-in transaction rollback — must manually track state if reverting changes

Changes are not persisted to disk until saveSourceFile() is called, so process crashes lose all edits

What makes it unique

Implements a wrapper-based abstraction over TypeScript Compiler API that decouples AST mutations from file I/O, allowing in-memory accumulation of changes across multiple files before batch persistence. This differs from direct Compiler API usage which requires managing file writes manually.

vs alternatives

Provides safer, more ergonomic in-memory code mutation than raw TypeScript Compiler API while maintaining full fidelity to the compiler's AST model, unlike higher-level tools like Babel which use their own AST representation.

semantic-aware code navigation and traversal

Medium confidence

Provides a comprehensive object-oriented API for traversing AST nodes with semantic awareness through the TypeChecker interface, enabling queries like 'find all usages of this symbol' and 'get the type of this expression'. Navigation methods include getParent(), getChildren(), forEachChild(), and specialized accessors for declaration kinds (getClass(), getFunction(), getInterface()). The system wraps compiler API's SyntaxKind and TypeFlags enums into strongly-typed Node subclasses, making traversal type-safe and IDE-friendly with autocomplete.

Solves for

I want to find all references to a specific variable or function across my codebaseI need to traverse the AST and understand the semantic meaning of nodes, not just their syntactic structureI want to query nodes by their kind (e.g., 'get all class declarations') with type-safe results

Best for

static analysis tool builders

code search and refactoring tools

IDE plugin developers

Requires

TypeScript 4.0+

Valid tsconfig.json or explicit compiler options

All imported dependencies available in node_modules

Limitations

TypeChecker-based semantic queries require full project context — cannot analyze isolated files without tsconfig.json

Performance degrades on large codebases (10k+ files) due to full type checking overhead

Symbol resolution requires all dependencies to be resolvable — missing node_modules breaks semantic analysis

What makes it unique

Wraps TypeScript's TypeChecker to provide semantic-aware navigation through a strongly-typed Node hierarchy, where each SyntaxKind maps to a specific TypeScript class (ClassDeclaration, FunctionDeclaration, etc.). This enables IDE-like autocomplete and type safety for AST traversal, unlike raw Compiler API which requires manual SyntaxKind checking.

vs alternatives

Combines syntactic AST traversal with semantic type information in a single unified API, whereas alternatives like Babel require separate passes for syntax and type analysis, or tools like ESLint use a different AST model entirely.

syntax-aware code formatting and whitespace preservation

Medium confidence

Provides APIs for querying and manipulating whitespace, formatting, and syntax details through methods like getLeadingTrivia(), getTrailingTrivia(), and getFullText(). Preserves existing formatting when modifying code, allowing surgical edits that don't reformat the entire file. Supports querying line and column positions, getting source text with or without trivia, and understanding the syntactic structure including comments and whitespace.

Solves for

I want to modify code while preserving the original formatting and commentsI need to get the exact source text of a node including comments and whitespaceI want to understand the line and column positions of nodes for error reporting

Best for

linters and code analysis tools

error reporting and diagnostics

code editors and IDE plugins

Requires

TypeScript 4.0+

Source file with valid syntax

Limitations

Trivia (comments, whitespace) handling is complex — modifying trivia can break formatting

Line/column position queries require scanning the entire file — can be slow for large files

No built-in formatting — must use external formatters like Prettier to reformat code

What makes it unique

Provides explicit APIs for accessing and manipulating trivia (comments, whitespace) separately from syntax nodes, enabling surgical edits that preserve formatting. This is more sophisticated than tools that treat trivia as part of the node, which can lose formatting information.

vs alternatives

Preserves formatting and comments during code modifications, whereas raw Compiler API loses trivia information, and template-based generators require reformatting after generation.

typescript-specific language feature support (generics, unions, intersections)

Medium confidence

Provides comprehensive support for TypeScript-specific type features through specialized node classes and type introspection APIs. Handles generics with type parameters and type arguments, union and intersection types, conditional types, mapped types, and type queries. Enables querying and modifying these features through methods like getTypeArguments(), getConstraint(), and getTypeParameters() on relevant node types.

Solves for

I want to extract type parameters from a generic class and understand their constraintsI need to analyze a union type and iterate over its constituent typesI want to understand and modify conditional types in my codebase

Best for

advanced code generators

type-aware refactoring tools

TypeScript-specific linters

Requires

TypeScript 4.0+

Understanding of advanced TypeScript type features

Valid project context for type checking

Limitations

Complex type features (conditional types, mapped types) can be difficult to analyze and modify

Type inference for complex expressions requires full type checking context

Some advanced type features may not be fully supported

What makes it unique

Provides dedicated node classes and APIs for TypeScript-specific type features (generics, unions, intersections, conditional types, mapped types), enabling type-aware code generation and analysis. This level of support is unique to TypeScript-focused tools.

vs alternatives

Handles advanced TypeScript type features that generic AST tools cannot, making it suitable for sophisticated type-aware code generation and analysis that requires understanding of the full TypeScript type system.

incremental compilation and caching for performance optimization

Medium confidence

Implements caching and incremental compilation strategies to optimize performance when working with large projects. Caches parsed ASTs and type information to avoid re-parsing unchanged files, and supports incremental updates when source files are modified. The Project class manages this caching internally, reusing compiler state across multiple operations to reduce redundant work.

Solves for

I want to perform multiple analyses on the same project without re-parsing all files each timeI need to update a single file and have the project reflect the changes without full recompilationI want to optimize performance when working with large codebases

Best for

long-running analysis tools

watch-mode code generators

IDE plugins

Requires

TypeScript 4.0+

Sufficient memory for caching (proportional to project size)

Limitations

Caching is automatic but opaque — no control over cache invalidation strategy

Incremental updates may not be fully incremental for all operations — some require full recompilation

Cache memory usage grows with project size — very large projects may run out of memory

What makes it unique

Implements automatic caching and incremental compilation within the Project class, reusing compiler state across operations to avoid redundant parsing and type checking. This is transparent to the user but significantly improves performance for multi-operation workflows.

vs alternatives

Provides automatic performance optimization without requiring manual cache management, whereas raw Compiler API requires creating new compiler instances for each operation, leading to redundant work.

declaration-aware code generation and modification

Medium confidence

Provides specialized APIs for creating and modifying TypeScript declarations (classes, interfaces, functions, imports) through a structure-based system that abstracts away low-level AST node creation. Uses a StructurePrinterFactory pattern to convert high-level structure objects (ClassDeclarationStructure, FunctionDeclarationStructure, etc.) into AST nodes, enabling developers to add methods to classes, create new interfaces, or modify function signatures without manually constructing SyntaxNodes. Supports JSDoc generation, decorators, access modifiers, and type annotations through the structure API.

Solves for

I want to programmatically add a new method to an existing class with proper type annotations and JSDocI need to create new TypeScript interfaces or classes from scratch with full type safetyI want to modify function signatures, add parameters, or change return types safely

Best for

code generators (ORMs, API clients, GraphQL code generators)

scaffolding tools

teams automating boilerplate generation

Requires

TypeScript 4.0+

Understanding of TypeScript declaration syntax

ts-morph package with structure types

Limitations

Structure API is TypeScript-specific — cannot generate JavaScript-only syntax like JSX without workarounds

Complex nested structures (deeply nested generics, conditional types) may require manual AST manipulation

No built-in formatting — generated code requires running through a formatter like Prettier

What makes it unique

Implements a StructurePrinterFactory pattern that converts high-level structure objects into AST nodes, abstracting away the complexity of manually constructing SyntaxNodes. This enables declarative code generation where developers describe 'what' (a class with these methods) rather than 'how' (create ClassDeclaration node, add MethodDeclaration children, etc.).

vs alternatives

Provides a more ergonomic and type-safe API for code generation than raw Compiler API, and maintains full TypeScript semantic fidelity unlike template-based generators which produce strings that must be parsed separately.

import and export statement manipulation

Medium confidence

Provides specialized APIs for analyzing and modifying import/export declarations through dedicated classes (ImportDeclaration, ExportDeclaration, ExportSpecifier) that abstract away the complexity of managing module specifiers, named imports, default imports, and re-exports. Supports operations like addImportDeclaration(), removeImportDeclaration(), and getImportDeclarations() with filtering by module name. Handles both ES6 module syntax and CommonJS require patterns, and can automatically organize imports or detect circular dependencies.

Solves for

I want to add a new import statement to a file and ensure it doesn't create duplicatesI need to find all files that import a specific module and update them when the module path changesI want to automatically organize imports (sort, remove unused) in my codebase

Best for

refactoring tools

module path migration tools

import optimization tools

Requires

TypeScript 4.0+

Valid source files with import/export statements

Project context for full import resolution

Limitations

Cannot detect dynamic imports (require() calls or import() expressions) — only static import/export statements

Circular dependency detection requires full project context and can be slow on large codebases

CommonJS require() manipulation is limited compared to ES6 import/export

What makes it unique

Provides dedicated ImportDeclaration and ExportDeclaration classes that wrap the compiler API's import/export node types, offering high-level methods like addImportDeclaration() that handle the complexity of managing module specifiers, named bindings, and default exports. Abstracts away the need to manually construct ImportSpecifier and ExportSpecifier nodes.

vs alternatives

Simpler and more ergonomic than raw Compiler API for import/export manipulation, and handles both ES6 and CommonJS patterns in a unified API, whereas alternatives like jscodeshift require separate handling for each module system.

type system introspection and querying

Medium confidence

Exposes TypeScript's type system through a wrapper API that allows querying type information for expressions, declarations, and symbols. Provides methods like getType(), getTypeAtLocation(), and getSymbolAtLocation() that return Type and Symbol objects with properties for checking type kinds (isStringLiteral(), isUnion(), isIntersection()), accessing type arguments, and resolving symbol definitions. Integrates with TypeChecker to enable semantic analysis without requiring developers to interact with the low-level Compiler API directly.

Solves for

I want to determine the type of an expression at a specific location in the codeI need to check if a type is a union, intersection, or generic type and extract its componentsI want to find the definition of a symbol and trace its type through the codebase

Best for

type-aware code generators

API documentation generators

type-checking linters

Requires

TypeScript 4.0+

Valid tsconfig.json with proper type checking configuration

All dependencies resolvable in node_modules

Limitations

Type introspection requires full project context and TypeChecker initialization — cannot work on isolated files

Complex generic types with deep nesting can be slow to resolve

Type narrowing and control flow analysis require analyzing the full function body, not just the expression

What makes it unique

Wraps TypeScript's TypeChecker and Type/Symbol APIs to provide a more ergonomic interface for type introspection, with helper methods for common type checks (isStringLiteral(), isUnion()) and type traversal. Abstracts away the complexity of working with TypeScript's internal type representation.

vs alternatives

Provides direct access to TypeScript's actual type system (not an approximation), making it more accurate than tools like Babel or ESLint which use simplified type models, while being more ergonomic than raw Compiler API.

file system abstraction with in-memory and real file system support

Medium confidence

Implements a FileSystemHost abstraction layer that decouples ts-morph from the underlying file system, supporting both real file system operations and in-memory virtual file systems. The abstraction allows creating a Project with a custom FileSystemHost implementation, enabling scenarios like testing without disk I/O, running in browser environments, or using custom storage backends. Provides methods like readFileSync(), writeFileSync(), and directoryExistsSync() that can be overridden to implement alternative storage strategies.

Solves for

I want to test my code transformation logic without writing to diskI need to run ts-morph in a browser or Node.js environment without file system accessI want to use a custom storage backend (database, cloud storage) instead of the local file system

Best for

testing frameworks for code generators

browser-based code editors

cloud-based development environments

Requires

TypeScript 4.0+

Understanding of FileSystemHost interface

Custom FileSystemHost implementation for non-standard file systems

Limitations

Custom FileSystemHost implementations must handle all file operations — incomplete implementations will cause runtime errors

In-memory file systems consume memory proportional to codebase size — not suitable for very large codebases (1M+ lines)

No built-in caching or optimization — custom implementations must handle performance themselves

What makes it unique

Implements a pluggable FileSystemHost interface that allows swapping the underlying file system implementation without changing application code. This enables the same ts-morph code to work with real file systems, in-memory virtual file systems, or custom backends by simply providing a different FileSystemHost implementation.

vs alternatives

More flexible than tools that are tightly coupled to the file system (like raw Compiler API), and enables testing and browser-based scenarios that would be impossible with direct file system access.

project-wide compiler configuration and diagnostics

Medium confidence

Manages TypeScript compiler options and project configuration through a Project class that can load tsconfig.json files, apply custom compiler options, and expose diagnostic information. Provides methods like getPreEmitDiagnostics() and getCompilerOptions() to access compiler configuration and error/warning information. Supports multiple source files within a single project context, enabling whole-project analysis and refactoring that respects compiler settings like strict mode, target version, and module resolution.

Solves for

I want to load a tsconfig.json file and apply its compiler options to my code analysisI need to get all compilation errors and warnings for my project to fix them programmaticallyI want to analyze code with specific compiler settings (strict mode, ES target version) applied

Best for

build tools and bundlers

CI/CD linters and validators

teams migrating TypeScript versions

Requires

TypeScript 4.0+

Valid tsconfig.json file (optional, can use inline compiler options)

All dependencies resolvable for type checking

Limitations

Compiler diagnostics require full type checking — can be slow on large projects (10k+ files)

Custom compiler options may not be fully supported — some advanced options require direct Compiler API usage

Diagnostics are read-only — cannot programmatically fix errors, only report them

What makes it unique

Provides a high-level Project API that manages TypeScript compiler configuration and diagnostics, abstracting away the complexity of initializing the Compiler API with correct options. Automatically loads and applies tsconfig.json settings, whereas raw Compiler API requires manual configuration parsing.

vs alternatives

Simpler than raw Compiler API for project-level configuration, and provides integrated diagnostics reporting, whereas alternatives like tsc require separate invocations to get error information.

decorator and jsdoc annotation analysis and generation

Medium confidence

Provides specialized APIs for analyzing and generating TypeScript decorators and JSDoc comments through Decorator and JSDocTag classes. Supports reading decorator arguments, generating new decorators with parameters, and parsing/generating JSDoc tags (param, returns, deprecated, etc.). Integrates with the declaration modification system to allow adding decorators and JSDoc to classes, methods, and properties programmatically.

Solves for

I want to find all classes decorated with @Entity and extract their decorator argumentsI need to generate JSDoc comments for auto-generated code with proper @param and @returns tagsI want to add decorators to methods when refactoring code

Best for

ORM and framework code generators

API documentation generators

decorator-based framework tools

Requires

TypeScript 4.0+

experimentalDecorators compiler option enabled for decorator support

Valid decorator syntax

Limitations

Decorator analysis is syntactic only — cannot evaluate decorator expressions at runtime

JSDoc parsing is basic — complex JSDoc syntax may not be fully supported

Decorator generation requires understanding of decorator syntax and semantics

What makes it unique

Provides dedicated Decorator and JSDocTag classes that parse and generate decorator and JSDoc syntax, enabling programmatic manipulation of metadata annotations. Integrates with the declaration API to allow adding decorators and JSDoc when creating or modifying declarations.

vs alternatives

More ergonomic than raw Compiler API for decorator/JSDoc manipulation, and provides structured access to decorator arguments and JSDoc tags rather than requiring manual string parsing.

multi-file batch refactoring with consistency checking

Medium confidence

Enables refactoring operations across multiple source files within a project context, maintaining consistency through symbol resolution and type checking. Supports operations like renaming symbols across files, moving declarations between files, and updating all references automatically. Uses the TypeChecker to ensure that refactoring operations respect type safety and don't break module boundaries or create circular dependencies.

Solves for

I want to rename a function and automatically update all call sites across my entire codebaseI need to move a class from one file to another and update all imports automaticallyI want to extract a function and ensure all references are updated consistently

Best for

IDE refactoring tools

large-scale code migration tools

monorepo management systems

Requires

TypeScript 4.0+

Valid tsconfig.json with proper module resolution

All dependencies resolvable

Limitations

Refactoring operations require full project context and type checking — slow on large codebases (10k+ files)

Some refactoring operations (like extract function) require manual implementation using lower-level APIs

Circular dependency detection and resolution is not automatic — requires manual handling

What makes it unique

Enables multi-file refactoring operations that maintain consistency through TypeChecker-based symbol resolution, ensuring that renaming or moving declarations updates all references correctly. This requires full project context, unlike file-by-file refactoring tools.

vs alternatives

Provides type-aware refactoring that respects module boundaries and type safety, whereas simple text-based refactoring tools (like sed or regex) can break code by missing context-dependent references.

source file creation and template-based code generation

Medium confidence

Provides APIs for creating new source files within a project and populating them with code using the structure-based generation system. Supports creating files with initial content (classes, interfaces, functions) through addSourceFileAtPath() and createSourceFile() methods that accept structure objects. Enables template-based code generation where developers define the structure of generated code declaratively rather than building AST nodes manually.

Solves for

I want to create a new TypeScript file with a class definition and export itI need to generate multiple files from a template (e.g., one file per entity in a database schema)I want to create a new file with proper imports and type annotations

Best for

code generators and scaffolders

API client generators

ORM code generators

Requires

TypeScript 4.0+

Valid project context

Write permissions to target directory

Limitations

Generated code requires formatting — ts-morph does not format output, requiring separate Prettier/dprint integration

Complex file structures may require multiple API calls — no built-in template language

No built-in validation of generated code — must manually verify syntax

What makes it unique

Integrates file creation with the structure-based code generation system, allowing developers to create new files with full type-safe content generation in a single operation. Abstracts away the complexity of manually constructing SourceFile nodes and populating them with declarations.

vs alternatives

More ergonomic than raw Compiler API for file creation, and maintains type safety throughout the generation process, unlike template-based generators which produce strings that must be parsed separately.

Capabilities are decomposed by AI analysis. Each maps to specific user intents and improves with match feedback.

Related Artifactssharing capabilities

Artifacts that share capabilities with ts-morph, ranked by overlap. Discovered automatically through the match graph.

Repository51

javaparser

Java 1-25 Parser and Abstract Syntax Tree for Java with advanced analysis functionalities.

lexical preservation and comment attributionast serialization and deserialization to jsonmetamodel-driven ast node generation and evolution

3 shared capabilities

Model24

Google: Gemini 2.0 Flash

Gemini Flash 2.0 offers a significantly faster time to first token (TTFT) compared to [Gemini Flash 1.5](/google/gemini-flash-1.5), while maintaining quality on par with larger models like [Gemini Pro 1.5](/google/gemini-pro-1.5). It...

context-aware code generation and analysis with language-agnostic ast reasoning

1 shared capability

Agent39

Mutable AI

AI agent for accelerated software development.

intelligent refactoring with structural preservation

1 shared capability

Product27

Mutable

AI-generated, up-to-date wiki for your...

real-time codebase ast parsing and semantic analysis

1 shared capability

Product20

Kilo Code

Open-source AI coding assistant for VS Code, JetBrains, and the CLI. [#opensource](https://github.com/Kilo-Org/kilocode)

inline code refactoring with semantic preservation

1 shared capability

MCP Server23

Semgrep

** - Enable AI agents to secure code with [Semgrep](https://semgrep.dev/).

abstract syntax tree (ast) generation and inspection

1 shared capability

Best For

✓code generation tools and scaffolders
✓automated refactoring engines
✓linters and static analysis tools that modify code
✓teams building custom TypeScript transformers
✓static analysis tool builders
✓code search and refactoring tools
✓IDE plugin developers
✓teams building custom linters

Known Limitations

⚠All changes held in memory until explicit save — can cause memory pressure on very large codebases (100k+ files)
⚠No built-in transaction rollback — must manually track state if reverting changes
⚠Changes are not persisted to disk until saveSourceFile() is called, so process crashes lose all edits
⚠TypeChecker-based semantic queries require full project context — cannot analyze isolated files without tsconfig.json
⚠Performance degrades on large codebases (10k+ files) due to full type checking overhead
⚠Symbol resolution requires all dependencies to be resolvable — missing node_modules breaks semantic analysis

Requirements

TypeScript 4.0+Node.js 12.20+ts-morph package installedValid tsconfig.json or explicit compiler optionsAll imported dependencies available in node_modulesSource file with valid syntaxUnderstanding of advanced TypeScript type featuresValid project context for type checking

Input / Output

Accepts: TypeScript/JavaScript source files, AST node references, code strings, AST nodes, symbol references, source file paths, source text, type nodes, generic declarations, type parameters, source files, compiler options, structure objects (ClassDeclarationStructure, etc.), existing AST nodes, type strings, module specifiers, import/export declarations, expressions, file paths, file contents, directory paths, tsconfig.json file path, compiler options object, decorator nodes, JSDoc comment strings, declaration nodes, refactoring operations, structure objects

Produces: modified AST nodes in memory, persisted source files on disk, AST node collections, type information, symbol definitions, trivia information, line/column positions, formatted source text, type parameter details, type argument information, cached ASTs, cached type information, modified AST nodes, generated source code, persisted TypeScript files, modified import/export statements, import organization reports, Type objects, Symbol information, type kind enums, file contents, directory listings, file metadata, compiler options, diagnostic information, error/warning reports, decorator information, JSDoc tag objects, generated decorators and comments, modified source files, refactoring reports, consistency validation results, created source files, generated code

UnfragileRank

Adoption58%(35% weight)

Quality45%(20% weight)

Ecosystem55%(25% weight)

Match Graph10%(15% weight)

Freshness75%(5% weight)

UnfragileRank is computed from adoption signals, documentation quality, ecosystem connectivity, match graph feedback, and freshness. No artifact can pay for a higher rank.

Type: Repository

13 capabilities

Visit ts-morph→

Repository Details

6,020

Stars

231

Forks

TypeScript

Language

MIT

License

Topics

astcode-generationjavascriptstatic-analysistypescript

Last commit: Apr 12, 2026

About

TypeScript Compiler API wrapper for static analysis and programmatic code changes.

Alternatives to ts-morph

IntelliCode50Extension

AI-assisted development

Compare →

GitHub Copilot Chat53Extension

AI chat features powered by Copilot

Compare →

GitHub Copilot52Extension

Your AI pair programmer

Compare →

Claude Code for VS Code52Extension

Claude Code for VS Code: Harness the power of Claude Code without leaving your IDE

Compare →

Are you the builder of ts-morph?

Claim this artifact to get a verified badge, access match analytics, see which intents users search for, and manage your listing.

Claim this artifact →Verification via email

Get the weekly brief

New tools, rising stars, and what's actually worth your time. No spam.

Data Sources

github

Looking for something else?

Search →

Capabilities13 decomposed

in-memory ast manipulation with deferred persistence

Medium confidence

Solves for

Best for

code generation tools and scaffolders

automated refactoring engines

linters and static analysis tools that modify code

Requires

TypeScript 4.0+

Node.js 12.20+

ts-morph package installed

Limitations

All changes held in memory until explicit save — can cause memory pressure on very large codebases (100k+ files)

No built-in transaction rollback — must manually track state if reverting changes

Changes are not persisted to disk until saveSourceFile() is called, so process crashes lose all edits

What makes it unique

vs alternatives

semantic-aware code navigation and traversal

Medium confidence

Solves for

Best for

static analysis tool builders

code search and refactoring tools

IDE plugin developers

Requires

TypeScript 4.0+

Valid tsconfig.json or explicit compiler options

All imported dependencies available in node_modules

Limitations

TypeChecker-based semantic queries require full project context — cannot analyze isolated files without tsconfig.json

Performance degrades on large codebases (10k+ files) due to full type checking overhead

Symbol resolution requires all dependencies to be resolvable — missing node_modules breaks semantic analysis

What makes it unique

vs alternatives

syntax-aware code formatting and whitespace preservation

Medium confidence

Solves for

Best for

linters and code analysis tools

error reporting and diagnostics

code editors and IDE plugins

Requires

TypeScript 4.0+

Source file with valid syntax

Limitations

Trivia (comments, whitespace) handling is complex — modifying trivia can break formatting

Line/column position queries require scanning the entire file — can be slow for large files

No built-in formatting — must use external formatters like Prettier to reformat code

What makes it unique

vs alternatives

Preserves formatting and comments during code modifications, whereas raw Compiler API loses trivia information, and template-based generators require reformatting after generation.

typescript-specific language feature support (generics, unions, intersections)

Medium confidence

Solves for

Best for

advanced code generators

type-aware refactoring tools

TypeScript-specific linters

Requires

TypeScript 4.0+

Understanding of advanced TypeScript type features

Valid project context for type checking

Limitations

Complex type features (conditional types, mapped types) can be difficult to analyze and modify

Type inference for complex expressions requires full type checking context

Some advanced type features may not be fully supported

What makes it unique

vs alternatives

incremental compilation and caching for performance optimization

Medium confidence

Solves for

Best for

long-running analysis tools

watch-mode code generators

IDE plugins

Requires

TypeScript 4.0+

Sufficient memory for caching (proportional to project size)

Limitations

Caching is automatic but opaque — no control over cache invalidation strategy

Incremental updates may not be fully incremental for all operations — some require full recompilation

Cache memory usage grows with project size — very large projects may run out of memory

What makes it unique

vs alternatives

Provides automatic performance optimization without requiring manual cache management, whereas raw Compiler API requires creating new compiler instances for each operation, leading to redundant work.

declaration-aware code generation and modification

Medium confidence

Solves for

Best for

code generators (ORMs, API clients, GraphQL code generators)

scaffolding tools

teams automating boilerplate generation

Requires

TypeScript 4.0+

Understanding of TypeScript declaration syntax

ts-morph package with structure types

Limitations

Structure API is TypeScript-specific — cannot generate JavaScript-only syntax like JSX without workarounds

Complex nested structures (deeply nested generics, conditional types) may require manual AST manipulation

No built-in formatting — generated code requires running through a formatter like Prettier

What makes it unique

vs alternatives

import and export statement manipulation

Medium confidence

Solves for

Best for

refactoring tools

module path migration tools

import optimization tools

Requires

TypeScript 4.0+

Valid source files with import/export statements

Project context for full import resolution

Limitations

Cannot detect dynamic imports (require() calls or import() expressions) — only static import/export statements

Circular dependency detection requires full project context and can be slow on large codebases

CommonJS require() manipulation is limited compared to ES6 import/export

What makes it unique

vs alternatives

type system introspection and querying

Medium confidence

Solves for

Best for

type-aware code generators

API documentation generators

type-checking linters

Requires

TypeScript 4.0+

Valid tsconfig.json with proper type checking configuration

All dependencies resolvable in node_modules

Limitations

Type introspection requires full project context and TypeChecker initialization — cannot work on isolated files

Complex generic types with deep nesting can be slow to resolve

Type narrowing and control flow analysis require analyzing the full function body, not just the expression

What makes it unique

vs alternatives

file system abstraction with in-memory and real file system support

Medium confidence

Solves for

Best for

testing frameworks for code generators

browser-based code editors

cloud-based development environments

Requires

TypeScript 4.0+

Understanding of FileSystemHost interface

Custom FileSystemHost implementation for non-standard file systems

Limitations

Custom FileSystemHost implementations must handle all file operations — incomplete implementations will cause runtime errors

In-memory file systems consume memory proportional to codebase size — not suitable for very large codebases (1M+ lines)

No built-in caching or optimization — custom implementations must handle performance themselves

What makes it unique

vs alternatives

More flexible than tools that are tightly coupled to the file system (like raw Compiler API), and enables testing and browser-based scenarios that would be impossible with direct file system access.

project-wide compiler configuration and diagnostics

Medium confidence

Solves for

Best for

build tools and bundlers

CI/CD linters and validators

teams migrating TypeScript versions

Requires

TypeScript 4.0+

Valid tsconfig.json file (optional, can use inline compiler options)

All dependencies resolvable for type checking

Limitations

Compiler diagnostics require full type checking — can be slow on large projects (10k+ files)

Custom compiler options may not be fully supported — some advanced options require direct Compiler API usage

Diagnostics are read-only — cannot programmatically fix errors, only report them

What makes it unique

vs alternatives

Simpler than raw Compiler API for project-level configuration, and provides integrated diagnostics reporting, whereas alternatives like tsc require separate invocations to get error information.

decorator and jsdoc annotation analysis and generation

Medium confidence

Solves for

Best for

ORM and framework code generators

API documentation generators

decorator-based framework tools

Requires

TypeScript 4.0+

experimentalDecorators compiler option enabled for decorator support

Valid decorator syntax

Limitations

Decorator analysis is syntactic only — cannot evaluate decorator expressions at runtime

JSDoc parsing is basic — complex JSDoc syntax may not be fully supported

Decorator generation requires understanding of decorator syntax and semantics

What makes it unique

vs alternatives

More ergonomic than raw Compiler API for decorator/JSDoc manipulation, and provides structured access to decorator arguments and JSDoc tags rather than requiring manual string parsing.

multi-file batch refactoring with consistency checking

Medium confidence

Solves for

Best for

IDE refactoring tools

large-scale code migration tools

monorepo management systems

Requires

TypeScript 4.0+

Valid tsconfig.json with proper module resolution

All dependencies resolvable

Limitations

Refactoring operations require full project context and type checking — slow on large codebases (10k+ files)

Some refactoring operations (like extract function) require manual implementation using lower-level APIs

Circular dependency detection and resolution is not automatic — requires manual handling

What makes it unique

vs alternatives

source file creation and template-based code generation

Medium confidence

Solves for

Best for

code generators and scaffolders

API client generators

ORM code generators

Requires

TypeScript 4.0+

Valid project context

Write permissions to target directory

Limitations

Generated code requires formatting — ts-morph does not format output, requiring separate Prettier/dprint integration

Complex file structures may require multiple API calls — no built-in template language

No built-in validation of generated code — must manually verify syntax

What makes it unique

vs alternatives

Capabilities are decomposed by AI analysis. Each maps to specific user intents and improves with match feedback.

Alternatives to ts-morph

IntelliCode50Extension

AI-assisted development

Compare →

GitHub Copilot Chat53Extension

AI chat features powered by Copilot

Compare →

GitHub Copilot52Extension

Your AI pair programmer

Compare →

Claude Code for VS Code52Extension

Claude Code for VS Code: Harness the power of Claude Code without leaving your IDE

Compare →

ts-morph

Capabilities13 decomposed

in-memory ast manipulation with deferred persistence

semantic-aware code navigation and traversal

syntax-aware code formatting and whitespace preservation

typescript-specific language feature support (generics, unions, intersections)

incremental compilation and caching for performance optimization

declaration-aware code generation and modification

import and export statement manipulation

type system introspection and querying

file system abstraction with in-memory and real file system support

project-wide compiler configuration and diagnostics

decorator and jsdoc annotation analysis and generation

multi-file batch refactoring with consistency checking

source file creation and template-based code generation

Related Artifactssharing capabilities

javaparser

Google: Gemini 2.0 Flash

Mutable AI

Mutable

Kilo Code

Semgrep

Best For

Known Limitations

Requirements

Input / Output

UnfragileRank

Repository Details

About

Categories

Alternatives to ts-morph

Are you the builder of ts-morph?

Get the weekly brief

Data Sources

ts-morph

Capabilities13 decomposed

in-memory ast manipulation with deferred persistence

semantic-aware code navigation and traversal

syntax-aware code formatting and whitespace preservation

typescript-specific language feature support (generics, unions, intersections)

incremental compilation and caching for performance optimization

declaration-aware code generation and modification

import and export statement manipulation

type system introspection and querying

file system abstraction with in-memory and real file system support

project-wide compiler configuration and diagnostics

decorator and jsdoc annotation analysis and generation

multi-file batch refactoring with consistency checking

source file creation and template-based code generation

Related Artifactssharing capabilities

javaparser

Google: Gemini 2.0 Flash

Mutable AI

Mutable

Kilo Code

Semgrep

Best For

Known Limitations

Requirements

Input / Output

UnfragileRank

Repository Details

About

Categories

Alternatives to ts-morph

Are you the builder of ts-morph?

Get the weekly brief

Data Sources