pi-shorthand 0.7.1 → 0.8.0

package/README.md

@@ -2,7 +2,7 @@
 
 ![A code call in Pi](https://raw.githubusercontent.com/sebinsua/pi-shorthand/main/docs/screenshot.png?v=2)
 
-A [Pi](https://github.com/earendil-works/pi) tool for editing repositories with Bun programs.
+A [Pi](https://github.com/earendil-works/pi) tool for editing repositories with Bun programs, with first-class support for TypeScript and JavaScript.
 
 ## Install
 

package/linux-observer.c

@@ -451,6 +451,7 @@ static void syscall_entry(pid_t pid, struct ptrace_syscall_info *info) {
         uint64_t flags = a[0];
         if (nr == SYS_clone3) {
             errno = 0; flags = ptrace(PTRACE_PEEKDATA, pid, (void *)(uintptr_t)a[0], 0);
+            if (errno == ESRCH) return;
             if (errno) die("clone flags unavailable");
         }
         if (flags & CLONE_UNTRACED) die("CLONE_UNTRACED is unsupported");
@@ -473,6 +474,7 @@ static void syscall_entry(pid_t pid, struct ptrace_syscall_info *info) {
         if (a[3] < 24) die("unsupported openat2 argument size");
         errno = 0;
         unsigned long resolve = ptrace(PTRACE_PEEKDATA, pid, (void *)(uintptr_t)(a[2] + 16), 0);
+        if (errno == ESRCH) return;
         if (errno || resolve) die("openat2 resolve modes are unsupported");
         path_access(pid, a[0], a[1], 1, OBSERVE_CONTENTS); break;
     }
@@ -661,18 +663,25 @@ int main(int argc, char **argv) {
         }
         if (!WIFSTOPPED(status)) die("unexpected process state");
         int event = (unsigned)status >> 16, signal = WSTOPSIG(status);
+        /* A stopped thread that SIGKILL or a sibling's exec retires reports ESRCH: its syscall never runs, and
+         * wait reports its death next, so there is nothing to observe and nothing to resume. */
         if (event == PTRACE_EVENT_SECCOMP) {
             struct ptrace_syscall_info info;
-            if (ptrace(PTRACE_GET_SYSCALL_INFO, pid, sizeof(info), &info) < 0 || info.op != PTRACE_SYSCALL_INFO_SECCOMP)
+            if (ptrace(PTRACE_GET_SYSCALL_INFO, pid, sizeof(info), &info) < 0) {
+                if (errno == ESRCH) continue;
                 die("syscall information unavailable");
+            }
+            if (info.op != PTRACE_SYSCALL_INFO_SECCOMP) die("syscall information unavailable");
             unresolved_external_permission = 0;
             syscall_entry(pid, &info);
             if (unresolved_external_permission) task(pid)->checking_permission = 1;
             signal = 0;
         } else if (signal == (SIGTRAP|0x80) && task(pid)->checking_permission) {
             struct ptrace_syscall_info info;
-            if (ptrace(PTRACE_GET_SYSCALL_INFO, pid, sizeof(info), &info) < 0)
+            if (ptrace(PTRACE_GET_SYSCALL_INFO, pid, sizeof(info), &info) < 0) {
+                if (errno == ESRCH) continue;
                 die("unresolved external path result unavailable");
+            }
             if (info.op == PTRACE_SYSCALL_INFO_EXIT) {
                 if (info.exit.rval != -EACCES && info.exit.rval != -EPERM)
                     die("unresolved external path was accessed");

package/move-analysis.ts

@@ -0,0 +1,191 @@
+/**
+ * What moving a top-level declaration affects, as TypeScript 7's checker sees it: the names the declaration
+ * depends on, whether the rest of its file still uses it, and which files refer to it. move-imports.ts turns
+ * this into edits. The checker comes from TypeScript's unstable API, so the typescript version is pinned.
+ */
+import { realpathSync } from "node:fs";
+import type { SgNode } from "@ast-grep/napi";
+import { API, SymbolFlags, type Project, type Symbol } from "typescript/unstable/async";
+import { getTouchingPropertyName, SyntaxKind, type Node, type SourceFile } from "typescript/unstable/ast";
+
+export interface MoveAnalysis {
+	/** Names the declaration refers to that are bound outside it: imports, the file's other declarations and globals. */
+	dependencies: Set<string>;
+	/** Local names of the source file's imports that nothing but the declaration uses, so they leave with it. */
+	importsOnlyItUses: Set<string>;
+	/** Code left in the source file still refers to the declaration. */
+	usedInSource: boolean;
+	/** Other files that refer to the declaration, by importing or re-exporting it. */
+	referencing: string[];
+	/** Files that use the declaration as a property of the module object: `ns.name`, `ns["name"]`, `{ name } = ns`. */
+	usedThroughModule: string[];
+}
+
+export interface MoveAnalysisInput {
+	root: string;
+	file: string;
+	/** The top-level statement being moved. */
+	node: SgNode;
+	/** The names it declares. */
+	names: string[];
+	/** Every JS/TS file in the repository, so that each lands in a TypeScript project. */
+	files: string[];
+}
+
+const REFERENCES = ["identifier", "type_identifier", "shorthand_property_identifier"];
+/** Where a declaration names what it declares, including `{ name }` in a destructuring declaration. */
+const DECLARED = ["identifier", "type_identifier", "shorthand_property_identifier_pattern"];
+
+const real = (file: string) => {
+	try {
+		return realpathSync(file);
+	} catch {
+		return file;
+	}
+};
+
+export async function analyzeMove({ root, file, node, names, files }: MoveAnalysisInput): Promise<MoveAnalysis> {
+	const api = new API({ cwd: root });
+	try {
+		const snapshot = await api.updateSnapshot({ openFiles: [...new Set([file, ...files])] });
+		const home = await snapshot.getDefaultProjectForFile(file);
+		const sourceFile = await home?.program.getSourceFile(file);
+		if (!home || !sourceFile) throw new Error(`refactor.move: TypeScript has no project containing ${file}`);
+		// A file in another project, such as another workspace package, imports the source through its own program.
+		const projects: Project[] = [];
+		for (const project of snapshot.getProjects())
+			if (await project.program.getSourceFile(file).catch(() => undefined)) projects.push(project);
+		return {
+			...(await dependencies(home, sourceFile, node)),
+			...(await references(projects, sourceFile, node, names)),
+		};
+	} finally {
+		await api.close();
+	}
+}
+
+/**
+ * Names in `node` whose symbol is declared outside it, or that resolve to nothing; and of those, the source
+ * file's imports that nothing outside `node` uses.
+ */
+async function dependencies(
+	project: Project,
+	sourceFile: SourceFile,
+	node: SgNode,
+): Promise<Pick<MoveAnalysis, "dependencies" | "importsOnlyItUses">> {
+	const { start, end } = node.range();
+	const inside = (reference: Node) => reference.getStart(sourceFile) >= start.index && reference.end <= end.index;
+	const onlyUsedInside = async (symbol: Symbol) => {
+		for (const handle of await project.checker.getReferencesToSymbolInFile(sourceFile.fileName, symbol)) {
+			const reference = await handle.resolve(project);
+			if (reference && !inside(reference) && !withinImport(reference)) return false;
+		}
+		return true;
+	};
+	const within = async (symbol: Symbol) => {
+		if (!symbol.declarations.length) return false;
+		for (const declaration of symbol.declarations) {
+			if (declaration.path !== sourceFile.path) return false;
+			const resolved = await declaration.resolve(project);
+			if (!resolved || resolved.getStart(sourceFile) < start.index || resolved.end > end.index) return false;
+		}
+		return true;
+	};
+	const identifiers = node.findAll({ rule: { any: REFERENCES.map((kind) => ({ kind })) } });
+	const symbols = await project.checker.getSymbolAtPosition(
+		sourceFile.fileName,
+		identifiers.map((identifier) => identifier.range().start.index),
+	);
+	const names = new Set<string>();
+	const importsOnlyItUses = new Set<string>();
+	for (const [index, identifier] of identifiers.entries()) {
+		const name = identifier.text();
+		if (names.has(name)) continue;
+		// `{ name }` declares a property; the value it reads is whatever `name` means there.
+		const symbol =
+			identifier.kind() === "shorthand_property_identifier"
+				? await project.checker.resolveName(
+						name,
+						SymbolFlags.Value,
+						getTouchingPropertyName(sourceFile, identifier.range().start.index),
+					)
+				: symbols[index];
+		if (symbol && (await within(symbol))) continue;
+		names.add(name);
+		const imported =
+			symbol &&
+			symbol.flags & SymbolFlags.Alias &&
+			symbol.declarations.every((declaration) => declaration.path === sourceFile.path);
+		if (imported && (await onlyUsedInside(symbol))) importsOnlyItUses.add(name);
+	}
+	return { dependencies: names, importsOnlyItUses };
+}
+
+/** A node inside an import declaration, such as the binding an import introduces. */
+function withinImport(node: Node): boolean {
+	for (let current: Node | undefined = node; current; current = current.parent)
+		if (current.kind === SyntaxKind.ImportDeclaration || current.kind === SyntaxKind.ImportEqualsDeclaration)
+			return true;
+	return false;
+}
+
+async function references(
+	projects: Project[],
+	sourceFile: SourceFile,
+	node: SgNode,
+	names: string[],
+): Promise<Pick<MoveAnalysis, "usedInSource" | "referencing" | "usedThroughModule">> {
+	const { start, end } = node.range();
+	const source = real(sourceFile.fileName);
+	const seen = new Set<string>();
+	const referencing = new Set<string>();
+	const usedThroughModule = new Set<string>();
+	let usedInSource = false;
+	for (const project of projects) {
+		const own = (await project.program.getSourceFile(sourceFile.fileName))!;
+		for (const name of names) {
+			// The first mention of a declared name in its declaration is where it is declared.
+			const declared = node.find({
+				rule: { any: DECLARED.map((kind) => ({ kind, regex: `^${name.replaceAll("$", "\\$")}$` })) },
+			});
+			if (!declared) continue;
+			const position = declared.range().start.index;
+			const entries = await project.checker.getReferencedSymbolsForNode(
+				getTouchingPropertyName(own, position),
+				position,
+			);
+			for (const handle of entries.flatMap((entry) => entry.references)) {
+				const key = `${handle.path}:${handle.index}`;
+				if (seen.has(key)) continue;
+				seen.add(key);
+				const reference = await handle.resolve(project);
+				if (!reference) continue;
+				const file = real(reference.getSourceFile().fileName);
+				if (file === source) {
+					if (reference.end <= start.index || reference.getStart() >= end.index) usedInSource = true;
+					continue;
+				}
+				referencing.add(file);
+				if (throughModule(reference)) usedThroughModule.add(file);
+			}
+		}
+	}
+	return { usedInSource, referencing: [...referencing], usedThroughModule: [...usedThroughModule] };
+}
+
+/** A reference that reads the declaration off a module object rather than binding it by name. */
+function throughModule(reference: Node): boolean {
+	const parent = reference.parent as Node & Record<string, unknown>;
+	switch (parent.kind) {
+		case SyntaxKind.PropertyAccessExpression:
+			return parent.name === reference;
+		case SyntaxKind.ElementAccessExpression:
+			return parent.argumentExpression === reference;
+		case SyntaxKind.QualifiedName:
+			return parent.right === reference;
+		case SyntaxKind.BindingElement:
+			return true;
+		default:
+			return false;
+	}
+}

package/move-imports.ts

@@ -1,11 +1,13 @@
 /**
- * Import and export updates for moving a top-level JS/TS declaration to another file. This is module and
- * scope bookkeeping, done from syntax: which names the declaration uses, which files import it, and what the
- * source file still needs. Cases syntax cannot settle soundly are refused before anything is written.
+ * Import and export updates for moving a top-level JS/TS declaration to another file. Which names the
+ * declaration uses and which files refer to it come from TypeScript's checker (move-analysis.ts); the
+ * statements to change are found and rewritten from syntax. Cases that cannot be updated soundly are refused
+ * before anything is written.
  */
 import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { dirname, extname, relative, resolve } from "node:path";
 import { parse, type SgNode } from "@ast-grep/napi";
+import type { MoveAnalysis } from "./move-analysis.ts";
 import { scriptLanguage } from "./placement.ts";
 
 export interface TextEdit {
@@ -34,8 +36,9 @@ export interface MoveInput {
 	node: SgNode;
 	targetFile: string;
 	targetRoot: SgNode;
-	/** Files that may mention any of these names: every JS/TS file Git sees would also do. */
-	filesMentioning: (names: string[]) => string[];
+	analysis: MoveAnalysis;
+	/** Files that may re-export a module wholesale, with `export *`. */
+	filesReexportingAll: () => string[];
 	/** Files that may load modules dynamically, with import() or require(). */
 	filesLoadingModules: () => string[];
 }
@@ -54,7 +57,6 @@ const DECLARATIONS = new Set([
 const TYPE_DECLARATIONS = new Set(["interface_declaration", "type_alias_declaration"]);
 /** Statements that declare a name without being a movable declaration: overloads and ambient or merged declarations. */
 const OTHER_DECLARATIONS = new Set(["function_signature", "ambient_declaration", "module", "internal_module"]);
-const REFERENCES = new Set(["identifier", "type_identifier", "shorthand_property_identifier"]);
 
 class MoveError extends Error {
 	constructor(message: string) {
@@ -92,6 +94,11 @@ function declaration(statement: SgNode): Declaration | null {
 	return { names, types, exported };
 }
 
+/** The names a top-level statement declares, for analysing it before a move. */
+export function declaredNames(statement: SgNode): string[] {
+	return declaration(statement)?.names ?? [];
+}
+
 /** The one top-level statement of a file that declares `symbol`, for moving it by name. */
 export function topLevelDeclaration(root: SgNode, symbol: string, file: string): SgNode {
 	const found = root.children().filter((statement) => {
@@ -117,91 +124,6 @@ function patternNames(pattern: SgNode | null): string[] {
 	return pattern.namedChildren().flatMap((child) => patternNames(child));
 }
 
-const FUNCTIONS = new Set([
-	"function_declaration",
-	"function_expression",
-	"generator_function_declaration",
-	"generator_function",
-	"arrow_function",
-	"method_definition",
-]);
-const DECLARED_BY_NAME = new Set([
-	"function_declaration",
-	"generator_function_declaration",
-	"class_declaration",
-	"abstract_class_declaration",
-	"interface_declaration",
-	"type_alias_declaration",
-	"enum_declaration",
-]);
-
-/** Names a scope node declares for itself: parameters, type parameters, and declarations directly in a block. */
-function scopeNames(scope: SgNode): Set<string> {
-	const names = new Set<string>();
-	const kind = String(scope.kind());
-	if (FUNCTIONS.has(kind) || kind === "class" || kind === "class_declaration" || DECLARED_BY_NAME.has(kind)) {
-		const parameters = scope.field("parameters");
-		for (const parameter of parameters?.namedChildren() ?? [])
-			for (const name of patternNames(parameter.field("pattern") ?? parameter.namedChildren()[0] ?? null))
-				names.add(name);
-		if (scope.field("parameter")) for (const name of patternNames(scope.field("parameter"))) names.add(name);
-		for (const parameter of scope.field("type_parameters")?.namedChildren() ?? [])
-			if (parameter.field("name")) names.add(parameter.field("name")!.text());
-		// A function or class expression can refer to its own name.
-		if ((kind === "function_expression" || kind === "class") && scope.field("name"))
-			names.add(scope.field("name")!.text());
-	}
-	if (kind === "catch_clause") for (const name of patternNames(scope.field("parameter"))) names.add(name);
-	if (kind === "for_in_statement") for (const name of patternNames(scope.field("left"))) names.add(name);
-	const statements =
-		kind === "statement_block" || kind === "class_body"
-			? scope.namedChildren()
-			: kind === "for_statement"
-				? [scope.field("initializer")]
-				: [];
-	for (const statement of statements) {
-		if (!statement) continue;
-		const inner = statement.kind() === "export_statement" ? statement.field("declaration") : statement;
-		if (!inner) continue;
-		if (inner.kind() === "lexical_declaration" || inner.kind() === "variable_declaration")
-			for (const declarator of inner.namedChildren())
-				if (declarator.kind() === "variable_declarator")
-					for (const name of patternNames(declarator.field("name"))) names.add(name);
-		if (DECLARED_BY_NAME.has(String(inner.kind())) && inner.field("name")) names.add(inner.field("name")!.text());
-	}
-	return names;
-}
-
-/**
- * Names a node refers to that no enclosing scope inside it declares: its dependencies, and globals. Each
- * reference is checked against its own enclosing scopes, so a nested local that shares a name with an
- * import does not hide the import's other uses.
- */
-function freeNames(node: SgNode): string[] {
-	const scopes = new Map<string, Set<string>>();
-	const declaredBy = (scope: SgNode) => {
-		const key = `${scope.kind()}:${scope.range().start.index}:${scope.range().end.index}`;
-		if (!scopes.has(key)) scopes.set(key, scopeNames(scope));
-		return scopes.get(key)!;
-	};
-	const { start, end } = node.range();
-	const names = new Set<string>();
-	for (const reference of node.findAll({ rule: { any: [...REFERENCES].map((kind) => ({ kind })) } })) {
-		const name = reference.text();
-		let local = false;
-		for (const ancestor of reference.ancestors()) {
-			const range = ancestor.range();
-			if (range.start.index < start.index || range.end.index > end.index) break;
-			if (declaredBy(ancestor).has(name)) {
-				local = true;
-				break;
-			}
-		}
-		if (!local) names.add(name);
-	}
-	return [...names];
-}
-
 interface Binding {
 	local: string;
 	/** The exported name the binding refers to; empty for default and namespace imports. */
@@ -219,6 +141,12 @@ function moduleName(statement: SgNode): string | undefined {
 	return source?.text().slice(1, -1);
 }
 
+/** A statement's import attributes, such as ` with { type: "json" }`, which must survive any rewrite of it. */
+function attributesOf(statement: SgNode): string {
+	const attributes = statement.children().find((child) => child.kind() === "import_attribute");
+	return attributes ? ` ${attributes.text()}` : "";
+}
+
 function quoteOf(statement: SgNode): string {
 	return statement.field("source")?.text()[0] ?? '"';
 }
@@ -359,17 +287,27 @@ function fileStyle(root: SgNode): Style {
 
 const JS_FOR_SOURCE: Record<string, string> = { ".ts": ".js", ".tsx": ".js", ".mts": ".mjs", ".cts": ".cjs" };
 
+/**
+ * A file's path with symlinks resolved, including a file that does not exist yet, through its nearest
+ * existing directory. Resolved imports are real paths, so a path through a symlink, such as macOS's /var for
+ * /private/var, must be resolved the same way before relative specifiers are computed between them.
+ */
+function canonical(file: string): string {
+	if (existsSync(file)) return realpathSync(file);
+	const parent = dirname(file);
+	return parent === file ? file : resolve(canonical(parent), file.slice(parent.length + 1));
+}
+
 function specifierFor(from: string, to: string, style: Style): string {
-	let path = relative(dirname(from), to).replaceAll("\\", "/");
+	let path = relative(dirname(canonical(from)), canonical(to)).replaceAll("\\", "/");
 	if (!path.startsWith(".")) path = `./${path}`;
 	const extension = extname(to);
-	if (style === "ts") return path;
+	// Only scripts resolve without their extension; JSON, stylesheets and other assets keep it.
+	if (style === "ts" || !EXTENSIONS.includes(extension)) return path;
 	const stem = path.slice(0, -extension.length);
 	return style === "js" ? stem + (JS_FOR_SOURCE[extension] ?? extension) : stem;
 }
 
-const escape = (text: string) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-
 const stem = (file: string) => file.slice(0, file.length - extname(file).length);
 
 /**
@@ -424,17 +362,21 @@ function importStatement(
 	specifiers: { text: string; typeOnly: boolean }[],
 	module: string,
 	quote: string,
+	attributes = "",
 ): string {
 	const allTypes = specifiers.every((specifier) => specifier.typeOnly);
 	const texts = specifiers.map((specifier) => {
 		const bare = specifier.text.replace(/^type\s+/, "");
 		return !allTypes && specifier.typeOnly ? `type ${bare}` : bare;
 	});
-	return `${keyword} ${namedClause(texts, allTypes)} from ${quote}${module}${quote};`;
+	return `${keyword} ${namedClause(texts, allTypes)} from ${quote}${module}${quote}${attributes};`;
 }
 
-/** Rebuild an import or re-export without some named specifiers; empty when nothing is left. */
-function withoutSpecifiers(statement: SgNode, remove: Set<string>): string {
+/**
+ * Rebuild an import or re-export without the bindings `drop` picks by imported and local name (a default or
+ * namespace import has no imported name); empty when nothing is left.
+ */
+function withoutSpecifiers(statement: SgNode, drop: (imported: string, local: string) => boolean): string {
 	const keyword = statement.kind() === "import_statement" ? "import" : "export";
 	const allTypes = typeOnlyStatement(statement);
 	const clause = statement
@@ -443,17 +385,20 @@ function withoutSpecifiers(statement: SgNode, remove: Set<string>): string {
 	const parts: string[] = [];
 	const named: string[] = [];
 	const collect = (list: SgNode) => {
-		for (const specifier of list.namedChildren())
-			if (!remove.has(specifier.field("name")!.text())) named.push(specifier.text());
+		for (const specifier of list.namedChildren()) {
+			const imported = specifier.field("name")!.text();
+			if (!drop(imported, (specifier.field("alias") ?? specifier.field("name"))!.text())) named.push(specifier.text());
+		}
 	};
 	if (clause?.kind() === "export_clause") collect(clause);
 	for (const part of clause?.kind() === "import_clause" ? clause.namedChildren() : []) {
 		if (part.kind() === "named_imports") collect(part);
-		else parts.push(part.text());
+		else if (!drop("", part.kind() === "namespace_import" ? part.namedChildren().at(-1)!.text() : part.text()))
+			parts.push(part.text());
 	}
 	if (named.length) parts.push(`{ ${named.join(", ")} }`);
 	if (!parts.length) return "";
-	return `${keyword} ${allTypes ? "type " : ""}${parts.join(", ")} from ${statement.field("source")!.text()};`;
+	return `${keyword} ${allTypes ? "type " : ""}${parts.join(", ")} from ${statement.field("source")!.text()}${attributesOf(statement)};`;
 }
 
 /** Where new imports go: after the last import, or at the start after a shebang and directives. */
@@ -500,11 +445,21 @@ export function planImports(input: MoveInput): ImportPlan | null {
 	const target = topLevel(targetRoot);
 	const sourceEdits: TextEdit[] = [];
 	const targetEdits: TextEdit[] = [];
-	const targetImports = new Map<string, { quote: string; specifiers: { text: string; typeOnly: boolean }[] }>();
-	const addTargetImport = (module: string, quote: string, specifier: { text: string; typeOnly: boolean }) => {
-		const entry = targetImports.get(module) ?? { quote, specifiers: [] };
+	// Keyed by module and attributes: the same module imported with and without attributes are distinct imports.
+	const targetImports = new Map<
+		string,
+		{ module: string; attributes: string; quote: string; specifiers: { text: string; typeOnly: boolean }[] }
+	>();
+	const addTargetImport = (
+		module: string,
+		quote: string,
+		specifier: { text: string; typeOnly: boolean },
+		attributes = "",
+	) => {
+		const key = `${module}\0${attributes}`;
+		const entry = targetImports.get(key) ?? { module, attributes, quote, specifiers: [] };
 		entry.specifiers.push(specifier);
-		targetImports.set(module, entry);
+		targetImports.set(key, entry);
 	};
 	const targetLines: string[] = [];
 	const style = (root: SgNode, fallback: SgNode) => {
@@ -529,12 +484,16 @@ export function planImports(input: MoveInput): ImportPlan | null {
 	}
 	for (const [statement, removed] of nowLocal) {
 		const { start, end } = statement.range();
-		targetEdits.push({ start: start.index, end: end.index, text: withoutSpecifiers(statement, removed) });
+		targetEdits.push({
+			start: start.index,
+			end: end.index,
+			text: withoutSpecifiers(statement, (imported) => removed.has(imported)),
+		});
 	}
 
 	// Dependencies: copy the source's imports, and import (exporting if needed) the source's own declarations.
 	const fromSource: { text: string; typeOnly: boolean }[] = [];
-	const free = new Set(freeNames(node));
+	const free = input.analysis.dependencies;
 	const order = [...sourceBindings.map((binding) => binding.local), ...source.declarations.keys()];
 	const ordered = [...order.filter((name) => free.has(name)), ...[...free].filter((name) => !order.includes(name))];
 	for (const name of new Set(ordered)) {
@@ -560,8 +519,13 @@ export function planImports(input: MoveInput): ImportPlan | null {
 					? specifierFor(targetFile, resolved, styleOf(binding.module))
 					: binding.module;
 			const quote = quoteOf(binding.statement);
-			if (binding.kind === "named") addTargetImport(module, quote, { text: binding.text, typeOnly: binding.typeOnly });
-			else targetLines.push(`import ${binding.typeOnly ? "type " : ""}${binding.text} from ${quote}${module}${quote};`);
+			const attributes = attributesOf(binding.statement);
+			if (binding.kind === "named")
+				addTargetImport(module, quote, { text: binding.text, typeOnly: binding.typeOnly }, attributes);
+			else
+				targetLines.push(
+					`import ${binding.typeOnly ? "type " : ""}${binding.text} from ${quote}${module}${quote}${attributes};`,
+				);
 		} else if (local) {
 			if (existing || target.declarations.has(name)) {
 				if (existing?.kind === "named" && existing.imported === name && importedFromSource(existing)) continue;
@@ -581,29 +545,37 @@ export function planImports(input: MoveInput): ImportPlan | null {
 		const module = specifierFor(targetFile, sourceFile, style(targetRoot, sourceRoot));
 		for (const specifier of fromSource) addTargetImport(module, '"', specifier);
 	}
-	for (const [module, { quote, specifiers }] of targetImports)
-		targetLines.push(importStatement("import", specifiers, module, quote));
+	for (const { module, attributes, quote, specifiers } of targetImports.values())
+		targetLines.push(importStatement("import", specifiers, module, quote, attributes));
 	if (targetLines.length) targetEdits.push(importInsertion(targetRoot, targetText, targetLines));
 
+	// Imports only the declaration used leave with it; a statement left with no bindings goes with its line.
+	const sourceNewline = sourceText.includes("\r\n") ? "\r\n" : "\n";
+	const unused = input.analysis.importsOnlyItUses;
+	for (const statement of new Set(
+		sourceBindings.filter((binding) => unused.has(binding.local)).map((binding) => binding.statement),
+	)) {
+		const { start, end } = statement.range();
+		const text = withoutSpecifiers(statement, (_, local) => unused.has(local));
+		const lineEnd = sourceText.startsWith(sourceNewline, end.index) ? end.index + sourceNewline.length : end.index;
+		sourceEdits.push({ start: start.index, end: text ? end.index : lineEnd, text });
+	}
+
 	// The source imports the declaration back if code left there still uses it.
-	const { start: movedStart, end: movedEnd } = node.range();
-	const stillUsed = sourceRoot
-		.findAll({ rule: { any: [...REFERENCES].map((kind) => ({ kind })) } })
-		.some((reference) => {
-			const { start } = reference.range();
-			if (start.index >= movedStart.index && start.index < movedEnd.index) return false;
-			if (!names.has(reference.text())) return false;
-			const statement = reference.ancestors().find((ancestor) => ancestor.parent()?.kind() === "program");
-			return statement?.kind() !== "import_statement" && !(statement && moduleName(statement));
-		});
+	const stillUsed = input.analysis.usedInSource;
 	if (stillUsed) {
 		const module = specifierFor(sourceFile, targetFile, style(sourceRoot, targetRoot));
 		const specifiers = moved.names.map((name) => ({ text: name, typeOnly: moved.types.has(name) }));
-		sourceEdits.push(importInsertion(sourceRoot, sourceText, [importStatement("import", specifiers, module, '"')]));
+		const insertion = importInsertion(sourceRoot, sourceText, [importStatement("import", specifiers, module, '"')]);
+		// Inserted after the last import: if that import is being rewritten, the new line joins its replacement.
+		const rewritten = sourceEdits.find((edit) => edit.start < insertion.start && insertion.start <= edit.end);
+		if (!rewritten) sourceEdits.push(insertion);
+		else if (rewritten.text) rewritten.text += insertion.text;
+		else rewritten.text = insertion.text.slice(sourceNewline.length) + sourceNewline;
 	}
 
 	// Importers of an exported declaration are repointed at the target. A module loaded with import() or
-	// require() is used as a whole object, which cannot be repointed name by name.
+	// require(), or read as an object, is used whole, which cannot be repointed name by name.
 	const importers: FileEdits[] = [];
 	if (moved.exported) {
 		for (const file of new Set(input.filesLoadingModules())) {
@@ -619,7 +591,13 @@ export function planImports(input: MoveInput): ImportPlan | null {
 					throw new MoveError(`${file} loads ${sourceFile} with ${callee}()`);
 			}
 		}
-		for (const file of new Set(input.filesMentioning(moved.names))) {
+		for (const file of input.analysis.usedThroughModule)
+			if (!sameFile(file, sourceFile))
+				throw new MoveError(`${file} uses ${moved.names.join(", ")} through a namespace import or module object`);
+		const candidates = new Set(
+			[...input.analysis.referencing, ...input.filesReexportingAll()].map((file) => resolve(file)),
+		);
+		for (const file of [...candidates].toSorted()) {
 			if (sameFile(file, sourceFile) || sameFile(file, targetFile)) continue;
 			const fileLang = scriptLanguage(file);
 			if (!fileLang) continue;
@@ -656,16 +634,6 @@ export function planImports(input: MoveInput): ImportPlan | null {
 								.find((part) => part.kind() === "named_imports")
 								?.namedChildren() ?? [])
 				).filter((specifier) => names.has(specifier.field("name")!.text()));
-				const namespace = clause?.namedChildren().find((part) => part.kind() === "namespace_import");
-				if (namespace) {
-					const local = namespace.namedChildren().at(-1)!.text();
-					if (
-						moved.names.some((name) =>
-							new RegExp(`(?<![\\w$])${escape(local)}\\s*\\.\\s*${escape(name)}(?![\\w$])`).test(text),
-						)
-					)
-						throw new MoveError(`${file} uses ${local}.<name> through a namespace import`);
-				}
 				if (!specifiers.length) continue;
 				const list = statement.kind() === "import_statement" ? imports : reexports;
 				for (const specifier of specifiers)
@@ -677,7 +645,9 @@ export function planImports(input: MoveInput): ImportPlan | null {
 				edits.push({
 					start: start.index,
 					end: end.index,
-					text: withoutSpecifiers(statement, new Set(specifiers.map((specifier) => specifier.field("name")!.text()))),
+					text: withoutSpecifiers(statement, (imported) =>
+						specifiers.some((specifier) => specifier.field("name")!.text() === imported),
+					),
 				});
 			}
 			if (!targetModule || (!imports.length && !reexports.length)) continue;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "pi-shorthand",
-	"version": "0.7.1",
-	"description": "Pi tool for editing repositories with Bun programs, text edits and structural transformations.",
+	"version": "0.8.0",
+	"description": "Pi tool for editing repositories with Bun programs, with first-class support for TypeScript and JavaScript.",
 	"keywords": [
 		"ast-grep",
 		"bun",
@@ -41,7 +41,7 @@
 		"@ast-grep/napi": "^0.45.3",
 		"@getgrit/cli": "0.1.0-alpha.1743007075",
 		"diff": "^9.0.0",
-		"typescript": "^7.0.2",
+		"typescript": "7.0.2",
 		"vscode-jsonrpc": "^9.0.2"
 	},
 	"devDependencies": {

package/placement.ts

@@ -3,7 +3,8 @@ import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from
 import { dirname, resolve } from "node:path";
 import { Lang, parse, type SgNode } from "@ast-grep/napi";
 import { editingFiles } from "./file-outcomes.ts";
-import { planImports, topLevelDeclaration } from "./move-imports.ts";
+import { analyzeMove, type MoveAnalysis } from "./move-analysis.ts";
+import { declaredNames, planImports, topLevelDeclaration } from "./move-imports.ts";
 
 export interface Match {
 	file: string;
@@ -124,10 +125,17 @@ interface Edit {
 	text: string;
 }
 
+/** Removes a statement, and the line break after it when it has whole lines to itself. */
 function removal(saved: Snapshot): Edit {
 	statement(saved.node);
 	const { start, end } = saved.node.range();
-	return { parent: saved.node.parent()!, start: start.index, end: end.index, text: "" };
+	const { source } = saved;
+	const lineStart = source.lastIndexOf("\n", start.index - 1) + 1;
+	const newline = source.startsWith("\r\n", end.index) ? 2 : source.startsWith("\n", end.index) ? 1 : 0;
+	const wholeLines = !source.slice(lineStart, start.index).trim() && newline > 0;
+	return wholeLines
+		? { parent: saved.node.parent()!, start: lineStart, end: end.index + newline, text: "" }
+		: { parent: saved.node.parent()!, start: start.index, end: end.index, text: "" };
 }
 
 function placement(text: string, destination: Destination) {
@@ -314,30 +322,44 @@ export function move(match: Match, destination: Destination, transform?: (text:
 	return editingFiles([match.file, ...destinationFiles(destination)], () => moveNodes(match, destination, transform));
 }
 
+/** What refactor.move needs from the repository besides the moved declaration. */
+export interface MoveFiles {
+	root: string;
+	/** Every JS/TS file Git sees. */
+	scripts: () => string[];
+	/** Files that may load modules dynamically, with import() or require(). */
+	loadingModules: () => string[];
+	/** Files that may re-export a module wholesale, with `export *`. */
+	reexportingAll: () => string[];
+}
+
 /**
  * Moves the top-level declaration of `symbol` in `from` to the end of `to`, updating imports: the target
  * imports what the declaration uses, the source imports it back if still needed, and files importing it
- * from the source import it from the target. `filesMentioning` lists JS/TS files that may contain the names.
+ * from the source import it from the target. TypeScript's checker decides what the declaration uses and who
+ * refers to it.
  */
-export function moveDeclaration(
-	from: string,
-	symbol: string,
-	to: string,
-	files: { mentioning: (names: string[]) => string[]; loadingModules: () => string[] },
-): void {
+export async function moveDeclaration(from: string, symbol: string, to: string, files: MoveFiles): Promise<void> {
 	const lang = scriptLanguage(from);
 	if (!lang || !scriptLanguage(to)) throw new Error("refactor.move requires JS/TS files");
 	const source = readFileSync(from, "utf8");
 	const node = topLevelDeclaration(parse(lang, source).root(), symbol, from);
+	const analysis = await analyzeMove({
+		root: files.root,
+		file: from,
+		node,
+		names: declaredNames(node),
+		files: files.scripts(),
+	});
 	const match = remember({ file: from, text: node.text(), node }, source);
-	return editingFiles([from, to], () => moveNodes(match, { endOf: file(to) }, undefined, files));
+	return editingFiles([from, to], () => moveNodes(match, { endOf: file(to) }, undefined, { ...files, analysis }));
 }
 
 function moveNodes(
 	match: Match,
 	destination: Destination,
 	transform?: (text: string) => string,
-	files?: { mentioning: (names: string[]) => string[]; loadingModules: () => string[] },
+	files?: MoveFiles & { analysis: MoveAnalysis },
 ): void {
 	const source = snapshot(match);
 	const deletion = removal(source);
@@ -366,8 +388,9 @@ function moveNodes(
 						node: source.node,
 						targetFile: target.saved.file,
 						targetRoot,
-						filesMentioning: files.mentioning,
+						analysis: files.analysis,
 						filesLoadingModules: files.loadingModules,
+						filesReexportingAll: files.reexportingAll,
 					})
 				: null;
 		const placed = { ...target.edit };

package/prelude.ts

@@ -307,70 +307,32 @@ function selectScope(helper: string, inputs: (string | FileTarget)[], select: (i
 	];
 }
 
-/** JS/TS files Git sees that contain any of these names as a word, for updating their imports. */
-function filesMentioning(names: string[]): string[] {
-	if (!names.length) return [];
-	const output = git(
-		[
-			"-C",
-			repositoryRoot,
-			"grep",
-			"-l",
-			"-z",
-			"-w",
-			"-F",
-			"--untracked",
-			...names.flatMap((name) => ["-e", name]),
-			"--",
-			"*.ts",
-			"*.tsx",
-			"*.mts",
-			"*.cts",
-			"*.js",
-			"*.jsx",
-			"*.mjs",
-			"*.cjs",
-		],
-		[1],
-	);
-	return output
+const SCRIPTS = ["*.ts", "*.tsx", "*.mts", "*.cts", "*.js", "*.jsx", "*.mjs", "*.cjs"];
+
+/** JS/TS files Git sees, tracked or new. */
+function scriptFiles(): string[] {
+	return git(["-C", repositoryRoot, "ls-files", "-z", "--cached", "--others", "--exclude-standard", "--", ...SCRIPTS])
 		.split("\0")
 		.filter(Boolean)
 		.map((file) => resolve(repositoryRoot, file));
 }
 
-/** JS/TS files Git sees that call import() or require(). */
-function filesLoadingModules(): string[] {
-	const output = git(
-		[
-			"-C",
-			repositoryRoot,
-			"grep",
-			"-l",
-			"-z",
-			"-E",
-			"--untracked",
-			"-e",
-			// The call may continue on the next line or after a comment: `import\n("./a")`.
-			"(^|[^[:alnum:]_$])(import|require)[[:space:]]*(\\(|/[*/]|$)",
-			"--",
-			"*.ts",
-			"*.tsx",
-			"*.mts",
-			"*.cts",
-			"*.js",
-			"*.jsx",
-			"*.mjs",
-			"*.cjs",
-		],
-		[1],
-	);
-	return output
+/** JS/TS files Git sees with a line matching an extended regular expression. */
+function scriptFilesMatching(pattern: string): string[] {
+	return git(["-C", repositoryRoot, "grep", "-l", "-z", "-E", "--untracked", "-e", pattern, "--", ...SCRIPTS], [1])
 		.split("\0")
 		.filter(Boolean)
 		.map((file) => resolve(repositoryRoot, file));
 }
 
+/** JS/TS files Git sees that call import() or require(). */
+const filesLoadingModules = () =>
+	// The call may continue on the next line or after a comment: `import\n("./a")`.
+	scriptFilesMatching("(^|[^[:alnum:]_$])(import|require)[[:space:]]*(\\(|/[*/]|$)");
+
+/** JS/TS files Git sees that may re-export a module wholesale, with `export *`, which may span lines. */
+const filesReexportingAll = () => scriptFilesMatching("(^|[^[:alnum:]_$])export[[:space:]]*(\\*|/[*/]|$)");
+
 /** A scope for a warning: short scopes in full, long ones as a count and the first few paths. */
 function describeScope(scope: FileScope): string {
 	const paths = (Array.isArray(scope) ? scope : [scope]).map((entry) =>
@@ -813,7 +775,12 @@ const globals = {
 				const to = explicitPath(pathArgument("refactor.move", options.to));
 				if (typeof options.symbol !== "string" || !options.symbol)
 					throw new TypeError("refactor.move expects { file, symbol, to } with a symbol name");
-				moveDeclaration(from, options.symbol, to, { mentioning: filesMentioning, loadingModules: filesLoadingModules });
+				await moveDeclaration(from, options.symbol, to, {
+					root: repositoryRoot,
+					scripts: scriptFiles,
+					loadingModules: filesLoadingModules,
+					reexportingAll: filesReexportingAll,
+				});
 			}),
 		renameFile: (options: RenameFileOptions) =>
 			logged("refactor.renameFile", [options], () => {

package/program-lint.ts

@@ -120,6 +120,6 @@ export function typeScriptApiHint(program: string, output: string, version: stri
 	if (!/(?:\bfrom\s*|\brequire\(\s*|\bimport\(\s*)["']typescript["']/.test(program)) return [];
 	if (!version || Number.parseInt(version, 10) < 7) return [];
 	return [
-		`typescript resolves to ${version} here, which has no compiler API (ts.createSourceFile, ts.SyntaxKind and so on). Use sg to read and edit syntax, or refactor.rename and refactor.renameFile for refactors.`,
+		`typescript resolves to ${version} here, which no longer has the classic compiler API (ts.createSourceFile, ts.SyntaxKind and so on); its unstable replacement is typescript/unstable/sync. Use sg to read and edit syntax, or refactor.rename and refactor.renameFile for refactors.`,
 	];
 }