ts-shove 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Alexander Fuerst
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,224 @@
+# ts-shove
+
+Move TypeScript files and directories at scale — all import paths are rewritten automatically via ts-morph AST analysis.
+
+> "We restructured a 300+ file TypeScript codebase — 15 batch moves, 860 tests passing throughout, zero data loss. The tool paid for itself on the first task."
+>
+> — Claude, Senior Autonomous Refactoring Engineer at Anthropic
+
+## Installation
+
+```bash
+pnpm add -D ts-shove
+```
+
+Or run directly:
+
+```bash
+npx ts-shove <source> <destination>
+```
+
+## Quick start
+
+### Move a single file
+
+```bash
+ts-shove src/components/Button.tsx src/ui/Button.tsx
+```
+
+### Move a directory
+
+Trailing slashes indicate a directory move. All files (TS and non-TS) are moved.
+
+```bash
+ts-shove src/components/ src/ui/
+```
+
+### Batch move from manifest
+
+```bash
+ts-shove moves.json
+```
+
+Where `moves.json` contains:
+
+```json
+{
+  "projectRoot": "/absolute/path/to/project",
+  "moves": {
+    "src/components/Button.tsx": "src/ui/Button.tsx",
+    "src/helpers/": "src/utils/"
+  },
+  "dryRun": false,
+  "useAliases": "preserve"
+}
+```
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `projectRoot` | `string` | git root or cwd | Absolute path to project root |
+| `moves` | `Record<string, string>` | (required) | Source-to-destination mapping. Trailing `/` = directory move |
+| `dryRun` | `boolean` | `false` | Preview without writing changes; detects destination conflicts |
+| `useAliases` | `"always" \| "never" \| "preserve"` | `"preserve"` | How to handle path alias imports |
+
+## CLI options
+
+| Flag | Short | Description |
+|------|-------|-------------|
+| `--dry-run` | `-n` | Preview changes without modifying files; detects destination conflicts |
+| `--root <dir>` | `-r` | Project root (default: git root or cwd) |
+| `--use-aliases <mode>` | `-a` | Alias handling: `always`, `never`, `preserve` (default: `preserve`) |
+| `--help` | `-h` | Show usage information |
+
+## Features
+
+- Rewrites static imports (`import { x } from "./path"`)
+- Rewrites dynamic imports (`import("./path")`, including inside `React.lazy()` callbacks)
+- Rewrites `require()` calls -- `require("./foo")` with relative paths are rewritten, same as dynamic `import()`
+- Rewrites re-exports (`export { x } from "./path"`)
+- Rewrites side-effect imports (`import "./styles"`)
+- Detects and preserves `.js`/`.jsx` extension convention in import specifiers
+- Resolves and rewrites tsconfig path aliases (`@/components/...`)
+- Supports both wildcard (`@/*`) and exact-match aliases
+- Moves non-TS files (CSS, JSON, SVG, etc.) during directory moves
+- Stages moves as git renames for clean history
+- Falls back to plain file operations in non-git projects
+- Protects against overwriting existing destination files
+- Cleans up empty directories after moves
+- Handles case-sensitive renames on case-insensitive filesystems (macOS)
+- Supports batch moves with correct ordering for overlapping source/destination paths
+
+## Alias handling
+
+The `--use-aliases` flag controls how tsconfig path aliases are treated in import specifiers.
+
+### `preserve` (default)
+
+Alias imports stay as aliases. If the target file moved, the alias path is updated. If the new location can't be expressed as an alias, falls back to a relative path.
+
+```
+# Before: import { Button } from "@/components/Button"
+# After:  import { Button } from "@/ui/Button"
+```
+
+### `always`
+
+All relative imports in affected files are converted to aliases where possible.
+
+```
+# Before: import { Button } from "../../ui/Button"
+# After:  import { Button } from "@/ui/Button"
+```
+
+### `never`
+
+All alias imports in affected files are converted to relative paths.
+
+```
+# Before: import { Button } from "@/ui/Button"
+# After:  import { Button } from "../../ui/Button"
+```
+
+## Dry-run conflict detection
+
+When `--dry-run` (or `dryRun: true` in the manifest) is used, ts-shove checks whether any destination path already exists on disk (and is not itself being moved away). Detected conflicts are reported in the console output and returned in the `MoveResult.conflicts` array. This lets you catch overwrites before any files are touched.
+
+## Programmatic usage
+
+```typescript
+import { executeMoves, type MoveManifest, type MoveResult } from "ts-shove";
+
+const result: MoveResult = executeMoves({
+  projectRoot: "/path/to/project",
+  moves: {
+    "src/old.ts": "src/new.ts",
+    "src/old-dir/": "src/new-dir/",
+  },
+  useAliases: "preserve",
+});
+
+console.log(`Moved ${result.filesMoved} files, rewrote ${result.importsRewritten} imports`);
+
+if (result.conflicts?.length) {
+  console.warn("Destination conflicts:", result.conflicts);
+}
+```
+
+## What it does NOT handle
+
+- **CSS/SCSS import paths** -- `@import` in stylesheets is not touched.
+- **Template literal imports** -- `` import(`./locale/${lang}`) `` is skipped (non-string-literal argument).
+- **Runtime string paths** -- Dynamically constructed import paths cannot be statically analyzed.
+- **Non-project files** -- Only files included in `tsconfig.json` are analyzed for import rewriting.
+- **Git rename tracking** -- Git detects renames by content similarity. When a move rewrites many import lines, the file content may change enough that git no longer recognizes it as a rename, and `git log --follow` won't track the history. This is a fundamental git limitation. For critical files, consider committing the rename and import rewrites as separate steps.
+
+## tsconfig and test files
+
+ts-shove uses ts-morph, which loads the project via `tsconfig.json`. **Only files included by tsconfig are analyzed for import rewriting.** If your tsconfig excludes test files (e.g., `"exclude": ["**/*.test.ts"]`), those files' imports will NOT be updated when you move their dependencies.
+
+If you try to move a file that is excluded from tsconfig, ts-shove will throw an early error:
+
+```
+Error: Source file is not included in tsconfig: src/utils.test.ts
+ts-morph cannot rewrite imports for files outside the project.
+Either add it to tsconfig "include" or use --tsconfig to specify a broader config.
+```
+
+**Recommended approach:** Use a tsconfig that includes your test files. Many projects already have a `tsconfig.json` that includes everything and a separate `tsconfig.build.json` for compilation. Point ts-shove at the broader one:
+
+```bash
+ts-shove --tsconfig tsconfig.json src/old.ts src/new.ts
+```
+
+Or if your main `tsconfig.json` excludes tests, create a `tsconfig.check.json`:
+
+```json
+{
+  "extends": "./tsconfig.json",
+  "exclude": []
+}
+```
+
+After a move, ts-shove reports stale-path warnings for string literals (like `vi.mock("./old/path")`) that match moved files but couldn't be automatically rewritten. Review these manually.
+
+## How it works
+
+1. **Expand moves** -- Directory moves are expanded to individual file mappings. Source paths are validated.
+2. **Move TS files in-memory** -- ts-morph moves each source file to its destination, automatically rewriting relative imports across the entire project.
+3. **Fix .js extensions** -- If the project convention uses `.js` extensions in import specifiers, they are restored (ts-morph strips them).
+4. **Fix dynamic imports, `require()` calls, and side-effect imports** -- ts-morph does not handle `import()` expressions, `require()` calls, or imports with no bindings. A separate AST pass rewrites these.
+5. **Handle aliases** -- Alias imports pointing to moved files are updated according to the chosen mode.
+6. **Write and clean up** -- Changes are saved to disk. Non-TS files are copied. Original files are deleted (via `git rm` when possible). Empty directories are removed.
+
+## Development
+
+```bash
+# Install dependencies
+pnpm install
+
+# Run tests
+pnpm test
+
+# Run tests in watch mode
+pnpm test:watch
+
+# Build
+pnpm build
+
+# Run in development (without building)
+pnpm dev -- <source> <destination>
+```
+
+Requires Node.js 20+ and a `tsconfig.json` at the project root.
+
+## Platform support
+
+Tested on macOS and Linux (via CI). Windows is expected to work (all path handling uses Node.js `path` module) but has not been tested. If you encounter Windows-specific issues, please [open an issue](https://github.com/fuerst-one/ts-shove/issues).
+
+## Credits
+
+Built on [ts-morph](https://github.com/dsherret/ts-morph) by David Sherret — the TypeScript AST library that makes all the import rewriting possible.
+
+## License
+
+MIT

package/dist/chunk-ASGBQAOU.js

@@ -0,0 +1,680 @@
+import {
+  findAllFiles,
+  findTsFiles,
+  resolveCandidates
+} from "./chunk-MRSPJM6J.js";
+
+// src/mover.ts
+import { Project, SyntaxKind } from "ts-morph";
+import * as fs from "fs";
+import * as path from "path";
+import { execFileSync } from "child_process";
+var CASE_RENAME_TEMP_SUFFIX = ".__ts_mv_tmp__";
+function expandMoves(moves, projectRoot) {
+  const expanded = /* @__PURE__ */ new Map();
+  for (const [src, dest] of Object.entries(moves)) {
+    const absSrc = path.resolve(projectRoot, src);
+    const absDest = path.resolve(projectRoot, dest);
+    if (!absSrc.startsWith(projectRoot + path.sep) && absSrc !== projectRoot) {
+      throw new Error(`Source path is outside project root: ${src}`);
+    }
+    if (!absDest.startsWith(projectRoot + path.sep) && absDest !== projectRoot) {
+      throw new Error(`Destination path is outside project root: ${dest}`);
+    }
+    if (src.endsWith("/")) {
+      if (!fs.existsSync(absSrc)) {
+        throw new Error(`Source directory does not exist: ${src}`);
+      }
+      for (const file of findAllFiles(absSrc)) {
+        const relative2 = path.relative(absSrc, file);
+        expanded.set(file, path.join(absDest, relative2));
+      }
+    } else {
+      if (!fs.existsSync(absSrc)) {
+        throw new Error(`Source file does not exist: ${src}`);
+      }
+      expanded.set(absSrc, absDest);
+    }
+  }
+  return expanded;
+}
+function detectJsExtensionConvention(project) {
+  const sourceFiles = project.getSourceFiles().slice(0, 30);
+  let jsExtCount = 0;
+  let totalImports = 0;
+  for (const sf of sourceFiles) {
+    for (const decl of sf.getImportDeclarations()) {
+      const specifier = decl.getModuleSpecifierValue();
+      if (specifier.startsWith(".")) {
+        totalImports++;
+        if (/\.jsx?$/.test(specifier)) jsExtCount++;
+      }
+    }
+  }
+  return totalImports > 0 && jsExtCount / totalImports > 0.5;
+}
+function isModuleSpecifierCall(call) {
+  const expr = call.getExpression();
+  if (expr.getKind() === SyntaxKind.ImportKeyword) return true;
+  if (expr.getKind() === SyntaxKind.Identifier && expr.getText() === "require") return true;
+  const arg = getCallStringArg(call);
+  if (!arg) return false;
+  const val = arg.getLiteralValue();
+  return val.startsWith("./") || val.startsWith("../");
+}
+function getCallStringArg(call) {
+  const args = call.getArguments();
+  if (args.length === 0) return null;
+  const arg = args[0];
+  if (arg.getKind() !== SyntaxKind.StringLiteral) return null;
+  return arg.asKind(SyntaxKind.StringLiteral);
+}
+function isExplicitIndexImport(specifier) {
+  return /\/index$/.test(specifier) || specifier === "./index" || specifier === "../index";
+}
+function fixSpecifierExtension(literal, sf, project) {
+  const specifier = literal.getLiteralValue();
+  if (!specifier.startsWith(".")) return;
+  if (specifier.endsWith(".js") || specifier.endsWith(".jsx")) return;
+  if (/\.[a-z]+$/i.test(specifier) && !/\.tsx?$/i.test(specifier)) return;
+  const isExplicitIndex = isExplicitIndexImport(specifier);
+  let fixedSpecifier = isExplicitIndex ? specifier : specifier.replace(/\/index$/, "");
+  const dir = path.dirname(sf.getFilePath());
+  const resolved = path.resolve(dir, fixedSpecifier);
+  if (!isExplicitIndex) {
+    const indexCandidates = [path.join(resolved, "index.ts"), path.join(resolved, "index.tsx")];
+    if (indexCandidates.some((c) => project.getSourceFile(c))) return;
+  }
+  const tsxCandidates = [resolved + ".tsx", path.join(resolved, "index.tsx")];
+  const isTsx = tsxCandidates.some((c) => project.getSourceFile(c));
+  literal.setLiteralValue(fixedSpecifier + (isTsx ? ".jsx" : ".js"));
+}
+function buildRelativeSpecifier(fromFilePath, targetFilePath, usesJsExt) {
+  let rel = path.relative(path.dirname(fromFilePath), targetFilePath);
+  if (!rel.startsWith(".")) rel = "./" + rel;
+  rel = rel.replace(/\.tsx?$/, "");
+  rel = rel.replace(/\/index$/, "");
+  if (usesJsExt) rel += targetFilePath.endsWith(".tsx") ? ".jsx" : ".js";
+  return rel;
+}
+function fixJsExtensions(project) {
+  for (const sf of project.getSourceFiles()) {
+    const declarations = [
+      ...sf.getImportDeclarations(),
+      ...sf.getExportDeclarations().filter((d) => d.getModuleSpecifierValue())
+    ];
+    for (const decl of declarations) {
+      const specifier = decl.getModuleSpecifierValue();
+      if (!specifier || !specifier.startsWith(".")) continue;
+      if (specifier.endsWith(".js") || specifier.endsWith(".jsx")) continue;
+      if (/\.[a-z]+$/i.test(specifier) && !/\.tsx?$/i.test(specifier)) continue;
+      const resolved = decl.getModuleSpecifierSourceFile();
+      if (resolved && /\/index\.tsx?$/.test(resolved.getFilePath()) && !isExplicitIndexImport(specifier)) continue;
+      const ext = resolved && /\.tsx$/.test(resolved.getFilePath()) ? ".jsx" : ".js";
+      decl.setModuleSpecifier(specifier + ext);
+    }
+    sf.getDescendantsOfKind(SyntaxKind.CallExpression).forEach((call) => {
+      if (!isModuleSpecifierCall(call)) return;
+      const literal = getCallStringArg(call);
+      if (!literal) return;
+      fixSpecifierExtension(literal, sf, project);
+    });
+    sf.getDescendantsOfKind(SyntaxKind.ImportType).forEach((importType) => {
+      const argument = importType.getArgument();
+      const literals = argument.getDescendantsOfKind(SyntaxKind.StringLiteral);
+      if (literals.length === 0) return;
+      const literal = literals[0];
+      fixSpecifierExtension(literal, sf, project);
+    });
+  }
+}
+function buildCallRewriteContext(moveMap, destPaths, aliasMappings, useAliases) {
+  const reverseMap = /* @__PURE__ */ new Map();
+  for (const [src, dest] of moveMap) {
+    reverseMap.set(dest, src);
+  }
+  return { reverseMap, destPaths, aliasMappings, useAliases };
+}
+function rewriteCallSpecifier(literal, filePath, originalFilePath, moveMap, destPaths, project, usesJsExt, aliasMappings, useAliases) {
+  const specifier = literal.getLiteralValue();
+  const isRelative = specifier.startsWith(".");
+  let resolvedBase = null;
+  if (isRelative) {
+    const dir = path.dirname(originalFilePath);
+    resolvedBase = path.resolve(dir, specifier).replace(/\.jsx?$/, "");
+  } else if (aliasMappings && aliasMappings.length > 0) {
+    resolvedBase = resolveAliasToAbsolute(specifier, aliasMappings);
+  }
+  if (!resolvedBase) return false;
+  const candidates = resolveCandidates(resolvedBase);
+  let targetPath = null;
+  for (const c of candidates) {
+    if (moveMap.has(c) || project.getSourceFile(c) || destPaths.has(c)) {
+      targetPath = c;
+      break;
+    }
+  }
+  if (!targetPath) return false;
+  const newTargetPath = moveMap.get(targetPath) ?? targetPath;
+  if (newTargetPath === targetPath && filePath === originalFilePath) return false;
+  let newSpecifier = null;
+  if (aliasMappings && aliasMappings.length > 0) {
+    const mode = useAliases ?? "preserve";
+    if (mode === "always" || mode === "preserve" && !isRelative) {
+      newSpecifier = absolutePathToAlias(newTargetPath, aliasMappings, usesJsExt);
+    }
+  }
+  if (!newSpecifier) {
+    newSpecifier = buildRelativeSpecifier(filePath, newTargetPath, usesJsExt);
+  }
+  if (newSpecifier !== specifier) {
+    literal.setLiteralValue(newSpecifier);
+    return true;
+  }
+  return false;
+}
+function fixCallExpressions(project, moveMap, usesJsExt, ctx) {
+  let count = 0;
+  for (const sf of project.getSourceFiles()) {
+    const filePath = sf.getFilePath();
+    const originalFilePath = ctx.reverseMap.get(filePath) ?? filePath;
+    sf.getDescendantsOfKind(SyntaxKind.CallExpression).forEach((call) => {
+      if (!isModuleSpecifierCall(call)) return;
+      const literal = getCallStringArg(call);
+      if (!literal) return;
+      if (rewriteCallSpecifier(literal, filePath, originalFilePath, moveMap, ctx.destPaths, project, usesJsExt, ctx.aliasMappings, ctx.useAliases)) {
+        count++;
+      }
+    });
+    sf.getDescendantsOfKind(SyntaxKind.ImportType).forEach((importType) => {
+      const argument = importType.getArgument();
+      const literals = argument.getDescendantsOfKind(SyntaxKind.StringLiteral);
+      if (literals.length === 0) return;
+      const literal = literals[0];
+      if (rewriteCallSpecifier(literal, filePath, originalFilePath, moveMap, ctx.destPaths, project, usesJsExt, ctx.aliasMappings, ctx.useAliases)) {
+        count++;
+      }
+    });
+  }
+  return count;
+}
+function fixSideEffectImports(project, moveMap, usesJsExt) {
+  let count = 0;
+  for (const sf of project.getSourceFiles()) {
+    const filePath = sf.getFilePath();
+    for (const decl of sf.getImportDeclarations()) {
+      if (decl.getNamedImports().length > 0) continue;
+      if (decl.getDefaultImport()) continue;
+      if (decl.getNamespaceImport()) continue;
+      const specifier = decl.getModuleSpecifierValue();
+      if (!specifier.startsWith(".")) continue;
+      const dir = path.dirname(filePath);
+      let resolved = path.resolve(dir, specifier).replace(/\.jsx?$/, "");
+      const candidates = resolveCandidates(resolved);
+      let targetPath = null;
+      for (const c of candidates) {
+        if (moveMap.has(c)) {
+          targetPath = c;
+          break;
+        }
+      }
+      if (!targetPath) continue;
+      const newTargetPath = moveMap.get(targetPath);
+      if (newTargetPath === targetPath) continue;
+      const newRel = buildRelativeSpecifier(filePath, newTargetPath, usesJsExt);
+      if (newRel !== specifier) {
+        decl.setModuleSpecifier(newRel);
+        count++;
+      }
+    }
+  }
+  return count;
+}
+function parseAliasMappings(project, projectRoot) {
+  const compilerOptions = project.getCompilerOptions();
+  const configPaths = compilerOptions.paths;
+  if (!configPaths) return [];
+  const baseUrl = compilerOptions.baseUrl ?? projectRoot;
+  const mappings = [];
+  for (const [pattern, targets] of Object.entries(configPaths)) {
+    if (targets.length === 0) continue;
+    if (pattern.endsWith("/*")) {
+      const prefix = pattern.slice(0, -1);
+      const target = targets[0];
+      const base = target.endsWith("/*") ? target.slice(0, -2) : target;
+      mappings.push({ prefix, baseDir: path.resolve(baseUrl, base) });
+    } else {
+      const target = targets[0];
+      mappings.push({ prefix: pattern, baseDir: path.resolve(baseUrl, target), isExact: true });
+    }
+  }
+  return mappings.sort((a, b) => b.baseDir.length - a.baseDir.length);
+}
+function absolutePathToAlias(absPath, mappings, usesJsExt) {
+  for (const mapping of mappings) {
+    if (mapping.isExact) {
+      const target = mapping.baseDir.replace(/\.tsx?$/, "");
+      const absNoExt = absPath.replace(/\.tsx?$/, "");
+      if (absNoExt === target) {
+        let specifier2 = mapping.prefix;
+        if (usesJsExt) specifier2 += absPath.endsWith(".tsx") ? ".jsx" : ".js";
+        return specifier2;
+      }
+      continue;
+    }
+    const rel = path.relative(mapping.baseDir, absPath);
+    if (rel.startsWith("..") || path.isAbsolute(rel)) continue;
+    let specifier = mapping.prefix + rel.replace(/\.tsx?$/, "");
+    if (usesJsExt) specifier += absPath.endsWith(".tsx") ? ".jsx" : ".js";
+    return specifier;
+  }
+  return null;
+}
+function resolveAliasToAbsolute(specifier, mappings) {
+  const bare = specifier.replace(/\.jsx?$/, "");
+  for (const mapping of mappings) {
+    if (mapping.isExact) {
+      if (bare === mapping.prefix) {
+        return mapping.baseDir.replace(/\.tsx?$/, "");
+      }
+      continue;
+    }
+    if (!bare.startsWith(mapping.prefix)) continue;
+    const remainder = bare.slice(mapping.prefix.length);
+    return path.resolve(mapping.baseDir, remainder);
+  }
+  return null;
+}
+function handleAliases(project, moveMap, involvedFiles, projectRoot, usesJsExt, mode) {
+  const mappings = parseAliasMappings(project, projectRoot);
+  if (mappings.length === 0) return 0;
+  let count = 0;
+  for (const sf of project.getSourceFiles()) {
+    const filePath = sf.getFilePath();
+    if (!involvedFiles.has(filePath)) continue;
+    const declarations = [
+      ...sf.getImportDeclarations(),
+      ...sf.getExportDeclarations().filter((d) => d.getModuleSpecifierValue())
+    ];
+    for (const decl of declarations) {
+      const specifier = decl.getModuleSpecifierValue();
+      if (!specifier) continue;
+      const isAlias = !specifier.startsWith(".");
+      if (isAlias) {
+        if (mode === "never") {
+          const resolved = resolveAliasToAbsolute(specifier, mappings);
+          if (!resolved) continue;
+          const candidates = resolveCandidates(resolved);
+          let targetFile = null;
+          for (const c of candidates) {
+            const newC = moveMap.get(c) ?? c;
+            if (project.getSourceFile(newC)) {
+              targetFile = newC;
+              break;
+            }
+          }
+          if (!targetFile) continue;
+          const relPath = buildRelativeSpecifier(filePath, targetFile, usesJsExt);
+          decl.setModuleSpecifier(relPath);
+          count++;
+        } else {
+          const resolved = resolveAliasToAbsolute(specifier, mappings);
+          if (!resolved) continue;
+          const candidates = resolveCandidates(resolved);
+          for (const candidate of candidates) {
+            const newPath = moveMap.get(candidate);
+            if (!newPath) continue;
+            const newAlias = absolutePathToAlias(newPath, mappings, usesJsExt);
+            if (newAlias) {
+              decl.setModuleSpecifier(newAlias);
+            } else {
+              const relPath = buildRelativeSpecifier(filePath, newPath, usesJsExt);
+              decl.setModuleSpecifier(relPath);
+            }
+            count++;
+            break;
+          }
+        }
+      } else if (!isAlias && mode === "always") {
+        const resolved = decl.getModuleSpecifierSourceFile();
+        if (!resolved) continue;
+        const targetPath = resolved.getFilePath();
+        const alias = absolutePathToAlias(targetPath, mappings, usesJsExt);
+        if (alias) {
+          decl.setModuleSpecifier(alias);
+          count++;
+        }
+      }
+    }
+  }
+  return count;
+}
+function detectStaleReferences(moveMap, projectRoot) {
+  const warnings = [];
+  const movedStems = /* @__PURE__ */ new Map();
+  for (const [src, dest] of moveMap) {
+    if (src === dest) continue;
+    const relSrc = path.relative(projectRoot, src).replace(/\.tsx?$/, "");
+    const relDest = path.relative(projectRoot, dest);
+    movedStems.set(relSrc, relDest);
+  }
+  if (movedStems.size === 0) return warnings;
+  const allFiles = findTsFiles(projectRoot);
+  for (const file of allFiles) {
+    const content = fs.readFileSync(file, "utf-8");
+    const relFile = path.relative(projectRoot, file);
+    for (const [oldStem, newDest] of movedStems) {
+      const fileDir = path.dirname(file);
+      const oldAbs = path.resolve(projectRoot, oldStem);
+      let oldRel = path.relative(fileDir, oldAbs);
+      if (!oldRel.startsWith(".")) oldRel = "./" + oldRel;
+      const patterns = [oldRel, oldRel + ".js", oldRel + ".jsx"];
+      for (const pattern of patterns) {
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i];
+          if (line.match(/\bfrom\s+["']/) && line.match(/^\s*(import|export)\s/)) continue;
+          if (line.match(/^\s*import\s+["']/)) continue;
+          const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+          const regex = new RegExp(`["']${escaped}["']`);
+          if (regex.test(line)) {
+            warnings.push(`${relFile}:${i + 1}: possible stale reference "${pattern}" (moved to ${newDest})`);
+            break;
+          }
+        }
+      }
+    }
+  }
+  return warnings;
+}
+function isGitRepo(dir) {
+  try {
+    execFileSync("git", ["rev-parse", "--is-inside-work-tree"], { cwd: dir, stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function checkDryRunConflicts(moveMap, projectRoot) {
+  const conflicts = [];
+  for (const [src, dest] of moveMap) {
+    if (src === dest) continue;
+    if (fs.existsSync(dest) && !moveMap.has(dest)) {
+      conflicts.push(dest);
+    }
+  }
+  if (conflicts.length > 0) {
+    console.log(`
+Conflicts detected: ${conflicts.length} destination(s) already exist`);
+    for (const c of conflicts) {
+      console.log(`  conflict: ${path.relative(projectRoot, c)}`);
+    }
+  }
+  return conflicts;
+}
+function performTopologicalSort(moveEntries, destPaths) {
+  const srcToIdx = /* @__PURE__ */ new Map();
+  for (let i = 0; i < moveEntries.length; i++) {
+    srcToIdx.set(moveEntries[i][0], i);
+  }
+  const sorted = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  function visit(idx) {
+    if (visited.has(idx)) return;
+    if (visiting.has(idx)) return;
+    visiting.add(idx);
+    const [, dest] = moveEntries[idx];
+    const depIdx = srcToIdx.get(dest);
+    if (depIdx !== void 0) {
+      visit(depIdx);
+    }
+    visiting.delete(idx);
+    visited.add(idx);
+    sorted.push(moveEntries[idx]);
+  }
+  for (let i = 0; i < moveEntries.length; i++) {
+    visit(i);
+  }
+  return sorted;
+}
+function stripIntroducedIndexSuffixes(project, preMoveCallSpecifiers, moveMap) {
+  const reverseForIndex = /* @__PURE__ */ new Map();
+  for (const [src, dest] of moveMap) reverseForIndex.set(dest, src);
+  for (const sf of project.getSourceFiles()) {
+    const filePath = sf.getFilePath();
+    const originalPath = reverseForIndex.get(filePath) ?? filePath;
+    const originalSpecs = preMoveCallSpecifiers.get(originalPath);
+    sf.getDescendantsOfKind(SyntaxKind.CallExpression).forEach((call) => {
+      if (!isModuleSpecifierCall(call)) return;
+      const literal = getCallStringArg(call);
+      if (!literal) return;
+      const val = literal.getLiteralValue();
+      if (!(val.endsWith("/index") || val.endsWith("/index.js") || val.endsWith("/index.jsx"))) return;
+      if (originalSpecs) {
+        const stripped = val.replace(/\/index(\.jsx?)?$/, "$1");
+        if (originalSpecs.has(val)) return;
+        if (originalSpecs.has(stripped) || !originalSpecs.has(val)) {
+          literal.setLiteralValue(stripped);
+        }
+      }
+    });
+  }
+}
+function collectInvolvedFiles(project, moveMap, aliasMappings, isTsFile) {
+  const involvedFiles = /* @__PURE__ */ new Set();
+  for (const dest of moveMap.values()) {
+    if (isTsFile(dest)) involvedFiles.add(dest);
+  }
+  for (const sf of project.getSourceFiles()) {
+    const filePath = sf.getFilePath();
+    if (involvedFiles.has(filePath)) continue;
+    let isInvolved = false;
+    const allDecls = [
+      ...sf.getImportDeclarations(),
+      ...sf.getExportDeclarations().filter((d) => d.getModuleSpecifierValue())
+    ];
+    for (const decl of allDecls) {
+      const target = decl.getModuleSpecifierSourceFile();
+      if (target && involvedFiles.has(target.getFilePath())) {
+        isInvolved = true;
+        break;
+      }
+      const specifier = decl.getModuleSpecifierValue();
+      if (specifier && !specifier.startsWith(".") && aliasMappings.length > 0) {
+        const resolved = resolveAliasToAbsolute(specifier, aliasMappings);
+        if (resolved) {
+          const candidates = resolveCandidates(resolved);
+          if (candidates.some((c) => moveMap.has(c))) {
+            isInvolved = true;
+            break;
+          }
+        }
+      }
+    }
+    if (isInvolved) involvedFiles.add(filePath);
+  }
+  return involvedFiles;
+}
+function commitMovesToDisk(moveMap, projectRoot, isTsFile, destPaths) {
+  let movedCount = 0;
+  for (const [src, dest] of moveMap) {
+    if (isTsFile(src)) continue;
+    if (src === dest) continue;
+    const destDir = path.dirname(dest);
+    fs.mkdirSync(destDir, { recursive: true });
+    if (fs.existsSync(dest)) {
+      throw new Error(`Destination file already exists: ${dest}`);
+    }
+    fs.copyFileSync(src, dest);
+    movedCount++;
+  }
+  const useGit = isGitRepo(projectRoot);
+  for (const [src, dest] of moveMap) {
+    if (src === dest) continue;
+    const isCaseRename = src.toLowerCase() === dest.toLowerCase();
+    if (isCaseRename) continue;
+    if (destPaths.has(src)) continue;
+    if (fs.existsSync(src)) {
+      if (useGit) {
+        try {
+          execFileSync("git", ["add", dest], { cwd: projectRoot, stdio: "pipe" });
+          execFileSync("git", ["rm", "--quiet", src], { cwd: projectRoot, stdio: "pipe" });
+        } catch {
+          fs.unlinkSync(src);
+        }
+      } else {
+        fs.unlinkSync(src);
+      }
+    }
+  }
+  return movedCount;
+}
+function cleanEmptyDirectories(moveMap, projectRoot) {
+  const dirsToCheck = /* @__PURE__ */ new Set();
+  for (const [src] of moveMap) {
+    dirsToCheck.add(path.dirname(src));
+  }
+  for (const dir of [...dirsToCheck].sort((a, b) => b.length - a.length)) {
+    let current = dir;
+    while (current !== projectRoot && current.startsWith(projectRoot)) {
+      try {
+        const entries = fs.readdirSync(current);
+        if (entries.length === 0) {
+          fs.rmdirSync(current);
+          console.log(`  removed empty dir: ${path.relative(projectRoot, current)}/`);
+        } else {
+          break;
+        }
+      } catch {
+        break;
+      }
+      current = path.dirname(current);
+    }
+  }
+}
+function executeMoves(manifest) {
+  const { projectRoot, dryRun = false, useAliases = "preserve" } = manifest;
+  const tsConfigPath = manifest.tsConfigPath ? path.resolve(projectRoot, manifest.tsConfigPath) : path.join(projectRoot, "tsconfig.json");
+  if (!fs.existsSync(tsConfigPath)) {
+    throw new Error(`No tsconfig.json found at ${tsConfigPath}`);
+  }
+  const moveMap = expandMoves(manifest.moves, projectRoot);
+  console.log(`Project: ${projectRoot}`);
+  console.log(`Dry run: ${dryRun}`);
+  console.log(`
+${moveMap.size} file(s) to move:
+`);
+  for (const [src, dest] of moveMap) {
+    console.log(`  ${path.relative(projectRoot, src)} -> ${path.relative(projectRoot, dest)}`);
+  }
+  const project = new Project({ tsConfigFilePath: tsConfigPath });
+  const isTsFile = (f) => /\.tsx?$/.test(f);
+  for (const [src] of moveMap) {
+    if (!isTsFile(src)) continue;
+    if (!project.getSourceFile(src)) {
+      throw new Error(
+        `Source file is not included in tsconfig: ${path.relative(projectRoot, src)}
+ts-morph cannot rewrite imports for files outside the project.
+Either add it to tsconfig "include" or use --tsconfig to specify a broader config.`
+      );
+    }
+  }
+  const usesJsExt = detectJsExtensionConvention(project);
+  console.log(`
+Import convention: ${usesJsExt ? ".js extensions" : "extensionless"}`);
+  const destPaths = new Set(moveMap.values());
+  if (dryRun) {
+    const conflicts = checkDryRunConflicts(moveMap, projectRoot);
+    console.log("\nDry run \u2014 no changes written.");
+    return { filesMoved: 0, importsRewritten: 0, conflicts: conflicts.length > 0 ? conflicts : void 0 };
+  }
+  let movedCount = 0;
+  const filteredEntries = [...moveMap.entries()].filter(([src, dest]) => src !== dest && isTsFile(src));
+  const moveEntries = performTopologicalSort(filteredEntries, destPaths);
+  const preMoveCallSpecifiers = /* @__PURE__ */ new Map();
+  for (const sf of project.getSourceFiles()) {
+    const specs = /* @__PURE__ */ new Set();
+    sf.getDescendantsOfKind(SyntaxKind.CallExpression).forEach((call) => {
+      if (!isModuleSpecifierCall(call)) return;
+      const literal = getCallStringArg(call);
+      if (!literal) return;
+      specs.add(literal.getLiteralValue());
+    });
+    if (specs.size > 0) preMoveCallSpecifiers.set(sf.getFilePath(), specs);
+  }
+  const movedSources = /* @__PURE__ */ new Set();
+  for (const [src, dest] of moveEntries) {
+    const sourceFile = project.getSourceFile(src);
+    if (!sourceFile) {
+      console.warn(`  warning: ${path.relative(projectRoot, src)} not found in project, skipping`);
+      continue;
+    }
+    const destDir = path.dirname(dest);
+    fs.mkdirSync(destDir, { recursive: true });
+    const isCaseRename = src.toLowerCase() === dest.toLowerCase() && src !== dest;
+    if (isCaseRename) {
+      const tempDest = dest + CASE_RENAME_TEMP_SUFFIX;
+      sourceFile.move(tempDest, { overwrite: true });
+      const tempFile = project.getSourceFile(tempDest);
+      tempFile.move(dest, { overwrite: true });
+    } else {
+      const destExistsOnDisk = fs.existsSync(dest);
+      const destMovedAway = movedSources.has(dest);
+      const needsOverwrite = destExistsOnDisk && destMovedAway;
+      sourceFile.move(dest, { overwrite: needsOverwrite });
+    }
+    movedSources.add(src);
+    movedCount++;
+  }
+  console.log(`
+Moved ${movedCount} TS file(s) in-memory`);
+  const tsMorphRewriteCount = project.getSourceFiles().filter((sf) => {
+    const fp = sf.getFilePath();
+    return !sf.isSaved() && !destPaths.has(fp);
+  }).length;
+  if (usesJsExt) {
+    console.log("Restoring .js import extensions...");
+    fixJsExtensions(project);
+  }
+  stripIntroducedIndexSuffixes(project, preMoveCallSpecifiers, moveMap);
+  const aliasMappings = parseAliasMappings(project, projectRoot);
+  const callCtx = buildCallRewriteContext(moveMap, destPaths, aliasMappings, useAliases);
+  const callExprFixCount = fixCallExpressions(project, moveMap, usesJsExt, callCtx);
+  if (callExprFixCount > 0) {
+    console.log(`Fixed ${callExprFixCount} dynamic import(s) and require() call(s)`);
+  }
+  const sideEffectFixCount = fixSideEffectImports(project, moveMap, usesJsExt);
+  if (sideEffectFixCount > 0) {
+    console.log(`Fixed ${sideEffectFixCount} side-effect import(s)`);
+  }
+  const involvedFiles = collectInvolvedFiles(project, moveMap, aliasMappings, isTsFile);
+  const aliasFixCount = handleAliases(project, moveMap, involvedFiles, projectRoot, usesJsExt, useAliases);
+  if (aliasFixCount > 0) {
+    console.log(`Fixed ${aliasFixCount} alias import(s)`);
+  }
+  console.log("Writing to disk...");
+  project.saveSync();
+  const staleWarnings = detectStaleReferences(moveMap, projectRoot);
+  if (staleWarnings.length > 0) {
+    console.log(`
+Warnings: ${staleWarnings.length} possible stale reference(s) found:`);
+    for (const w of staleWarnings) {
+      console.log(`  ${w}`);
+    }
+  }
+  const nonTsMovedCount = commitMovesToDisk(moveMap, projectRoot, isTsFile, destPaths);
+  movedCount += nonTsMovedCount;
+  cleanEmptyDirectories(moveMap, projectRoot);
+  console.log("\nDone! Run `npx tsc --noEmit` to verify.");
+  const totalRewrites = tsMorphRewriteCount + callExprFixCount + sideEffectFixCount + aliasFixCount;
+  return {
+    filesMoved: movedCount,
+    importsRewritten: totalRewrites,
+    warnings: staleWarnings.length > 0 ? staleWarnings : void 0
+  };
+}
+
+export {
+  executeMoves
+};

package/dist/chunk-MRSPJM6J.js

@@ -0,0 +1,65 @@
+// src/resolver.ts
+import * as fs from "fs";
+import * as path from "path";
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", ".next", ".test", "coverage"]);
+function walkDir(dir, filter) {
+  const results = [];
+  if (!fs.existsSync(dir)) return results;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (SKIP_DIRS.has(entry.name)) continue;
+      results.push(...walkDir(fullPath, filter));
+    } else if (entry.isFile() && filter(entry.name)) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+function findTsFiles(dir) {
+  return walkDir(dir, (name) => /\.tsx?$/.test(name) && !name.endsWith(".d.ts"));
+}
+function findAllFiles(dir) {
+  return walkDir(dir, () => true);
+}
+function resolveCandidates(base) {
+  return [base + ".ts", base + ".tsx", path.join(base, "index.ts"), path.join(base, "index.tsx")];
+}
+function resolveImportTarget(importerPath, specifier) {
+  if (!specifier.startsWith(".")) return null;
+  const dir = path.dirname(importerPath);
+  let resolved = path.resolve(dir, specifier);
+  resolved = resolved.replace(/\.jsx?$/, "");
+  const candidates = resolveCandidates(resolved);
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function computeNewImportPath(importerNewPath, targetNewPath, usesJsExtension) {
+  let relative2 = path.relative(
+    path.dirname(importerNewPath),
+    targetNewPath
+  );
+  if (!relative2.startsWith(".")) {
+    relative2 = "./" + relative2;
+  }
+  relative2 = relative2.replace(/\.tsx?$/, "");
+  if (usesJsExtension) {
+    const ext = targetNewPath.endsWith(".tsx") ? ".jsx" : ".js";
+    if (!relative2.endsWith(ext)) {
+      relative2 += ext;
+    }
+  }
+  return relative2;
+}
+
+export {
+  findTsFiles,
+  findAllFiles,
+  resolveCandidates,
+  resolveImportTarget,
+  computeNewImportPath
+};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+import {
+  executeMoves
+} from "./chunk-ASGBQAOU.js";
+import "./chunk-MRSPJM6J.js";
+
+// src/cli.ts
+import * as fs from "fs";
+import * as path from "path";
+function printUsage() {
+  console.log(`
+ts-shove \u2014 Move TypeScript files with automatic import rewriting
+
+Usage:
+  ts-shove <manifest.json>                    Batch move from manifest file
+  ts-shove <source> <destination>             Move a single file
+  ts-shove <source/dir/> <dest/dir/>          Move a directory (trailing slash)
+  ts-shove --dry-run <manifest.json>          Preview without changes
+  ts-shove --dry-run <source> <destination>   Preview single move
+
+Manifest format:
+  {
+    "projectRoot": "/absolute/path",       (optional \u2014 defaults to git root or cwd)
+    "moves": {
+      "src/old.ts": "src/new.ts",          (file move)
+      "src/old-dir/": "src/new-dir/"       (directory move \u2014 trailing slash)
+    },
+    "dryRun": false,                       (optional)
+    "useAliases": "preserve"               (optional \u2014 always | never | preserve)
+  }
+
+Options:
+  --dry-run, -n              Show what would change without modifying files
+  --root, -r <dir>           Project root (default: git root or cwd)
+  --tsconfig, -t <path>      Path to tsconfig.json (default: tsconfig.json in project root)
+  --use-aliases, -a <mode>   Alias handling: always, never, preserve (default: preserve)
+  --help, -h                 Show this help
+`);
+}
+function findGitRoot() {
+  let dir = process.cwd();
+  while (dir !== path.dirname(dir)) {
+    if (fs.existsSync(path.join(dir, ".git"))) return dir;
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  let dryRun = false;
+  let root = null;
+  let tsConfigPath;
+  let useAliases;
+  const positional = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--help" || arg === "-h") {
+      printUsage();
+      process.exit(0);
+    } else if (arg === "--dry-run" || arg === "-n") {
+      dryRun = true;
+    } else if ((arg === "--root" || arg === "-r") && i + 1 < args.length) {
+      root = path.resolve(args[++i]);
+    } else if ((arg === "--tsconfig" || arg === "-t") && i + 1 < args.length) {
+      tsConfigPath = args[++i];
+    } else if ((arg === "--use-aliases" || arg === "-a") && i + 1 < args.length) {
+      const val = args[++i];
+      if (val !== "always" && val !== "never" && val !== "preserve") {
+        console.error(`Invalid --use-aliases value: ${val}. Expected: always, never, preserve`);
+        process.exit(1);
+      }
+      useAliases = val;
+    } else if (!arg.startsWith("-")) {
+      positional.push(arg);
+    } else {
+      console.error(`Unknown option: ${arg}`);
+      process.exit(1);
+    }
+  }
+  if (positional.length === 0) {
+    printUsage();
+    process.exit(1);
+  }
+  if (positional.length === 1) {
+    const manifestPath = path.resolve(positional[0]);
+    if (!fs.existsSync(manifestPath)) {
+      console.error(`Manifest not found: ${manifestPath}`);
+      process.exit(1);
+    }
+    const manifest2 = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+    manifest2.projectRoot = manifest2.projectRoot ? path.resolve(manifest2.projectRoot) : root ?? findGitRoot() ?? process.cwd();
+    if (dryRun) manifest2.dryRun = true;
+    if (useAliases) manifest2.useAliases = useAliases;
+    if (tsConfigPath) manifest2.tsConfigPath = tsConfigPath;
+    return manifest2;
+  }
+  if (positional.length === 2) {
+    const projectRoot = root ?? findGitRoot() ?? process.cwd();
+    return {
+      projectRoot,
+      moves: { [positional[0]]: positional[1] },
+      dryRun,
+      useAliases,
+      tsConfigPath
+    };
+  }
+  console.error("Expected 1 (manifest) or 2 (source destination) arguments");
+  process.exit(1);
+}
+var manifest = parseArgs(process.argv);
+try {
+  executeMoves(manifest);
+} catch (err) {
+  console.error("\nError:", err instanceof Error ? err.message : err);
+  process.exit(1);
+}

package/dist/mover.d.ts

@@ -0,0 +1,17 @@
+type AliasMode = "always" | "never" | "preserve";
+interface MoveManifest {
+    projectRoot: string;
+    moves: Record<string, string>;
+    dryRun?: boolean;
+    useAliases?: AliasMode;
+    tsConfigPath?: string;
+}
+interface MoveResult {
+    filesMoved: number;
+    importsRewritten: number;
+    conflicts?: string[];
+    warnings?: string[];
+}
+declare function executeMoves(manifest: MoveManifest): MoveResult;
+
+export { type AliasMode, type MoveManifest, type MoveResult, executeMoves };

package/dist/mover.js

@@ -0,0 +1,7 @@
+import {
+  executeMoves
+} from "./chunk-ASGBQAOU.js";
+import "./chunk-MRSPJM6J.js";
+export {
+  executeMoves
+};

package/dist/resolver.d.ts

@@ -0,0 +1,7 @@
+declare function findTsFiles(dir: string): string[];
+declare function findAllFiles(dir: string): string[];
+declare function resolveCandidates(base: string): string[];
+declare function resolveImportTarget(importerPath: string, specifier: string): string | null;
+declare function computeNewImportPath(importerNewPath: string, targetNewPath: string, usesJsExtension: boolean): string;
+
+export { computeNewImportPath, findAllFiles, findTsFiles, resolveCandidates, resolveImportTarget };

package/dist/resolver.js

@@ -0,0 +1,14 @@
+import {
+  computeNewImportPath,
+  findAllFiles,
+  findTsFiles,
+  resolveCandidates,
+  resolveImportTarget
+} from "./chunk-MRSPJM6J.js";
+export {
+  computeNewImportPath,
+  findAllFiles,
+  findTsFiles,
+  resolveCandidates,
+  resolveImportTarget
+};

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "ts-shove",
+  "version": "1.0.0",
+  "description": "Move TypeScript files with automatic import path rewriting via ts-morph AST analysis",
+  "type": "module",
+  "license": "MIT",
+  "author": "Alexander Fuerst <alexander@fuerst.one>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fuerst-one/ts-shove.git"
+  },
+  "homepage": "https://github.com/fuerst-one/ts-shove#readme",
+  "bugs": "https://github.com/fuerst-one/ts-shove/issues",
+  "keywords": [
+    "typescript",
+    "move",
+    "rename",
+    "refactor",
+    "imports",
+    "ts-morph",
+    "ast",
+    "codemod",
+    "cli"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=20"
+  },
+  "bin": {
+    "ts-shove": "dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/mover.js",
+      "types": "./dist/mover.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup src/cli.ts src/mover.ts src/resolver.ts --format esm --target node20 --clean --dts",
+    "dev": "tsx src/cli.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "pnpm test && pnpm build"
+  },
+  "dependencies": {
+    "ts-morph": "^25.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "@types/react": "^19.2.14",
+    "react": "^19.2.4",
+    "tsup": "^8.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^4.1.1"
+  }
+}