atmn 1.1.25 → 2.0.0

package/src/render/renderSandboxes.ts

@@ -0,0 +1,92 @@
+import chalk from "chalk";
+import type { ListSandboxesResponse } from "../generated/client";
+import { stripTerminalControls } from "./stripTerminalControls";
+
+/**
+ * Headless rendering, like the preview: a table a terminal or a CI log can
+ * read. Nothing here decides anything — it reports what `sandboxes.list` said.
+ */
+
+export type SandboxRow = ListSandboxesResponse["list"][number];
+
+const MINUTE = 60_000;
+const HOUR = 60 * MINUTE;
+const DAY = 24 * HOUR;
+const MONTH = 30 * DAY;
+const YEAR = 365 * DAY;
+
+export const NO_SANDBOXES =
+	"No sandboxes yet. Create one with atmn sandbox create <name>.";
+
+const HEADERS = ["ID", "NAME", "CREATED"] as const;
+const GAP = "  ";
+const CURRENT_MARKER = "← current";
+
+/** How old, in the terms a reader thinks in; `--json` carries the exact stamp. */
+export const relativeAge = ({
+	createdAt,
+	now,
+}: {
+	createdAt: number;
+	now: number;
+}): string => {
+	const elapsed = Math.max(0, now - createdAt);
+	if (elapsed < MINUTE) return "just now";
+	if (elapsed < HOUR) return `${Math.floor(elapsed / MINUTE)}m ago`;
+	if (elapsed < DAY) return `${Math.floor(elapsed / HOUR)}h ago`;
+	if (elapsed < MONTH) return `${Math.floor(elapsed / DAY)}d ago`;
+	if (elapsed < YEAR) return `${Math.floor(elapsed / MONTH)}mo ago`;
+	return `${Math.floor(elapsed / YEAR)}y ago`;
+};
+
+const columnWidths = ({ rows }: { rows: string[][] }): number[] =>
+	HEADERS.map((header, column) =>
+		Math.max(header.length, ...rows.map((row) => (row[column] ?? "").length)),
+	);
+
+const tableLine = ({
+	cells,
+	widths,
+	marker,
+}: {
+	cells: readonly string[];
+	widths: number[];
+	marker: string;
+}): string =>
+	`${cells
+		.map((cell, column) => cell.padEnd(widths[column] ?? 0))
+		.join(GAP)}${marker}`.trimEnd();
+
+export const renderSandboxes = ({
+	sandboxes,
+	currentSandboxId,
+	now = Date.now(),
+}: {
+	sandboxes: SandboxRow[];
+	/** The sandbox `--sandbox` or AUTUMN_SANDBOX_ID points at, if any. */
+	currentSandboxId?: string;
+	now?: number;
+}): string => {
+	if (sandboxes.length === 0) return chalk.dim(NO_SANDBOXES);
+
+	const rows = sandboxes.map((sandbox) => [
+		sandbox.id,
+		stripTerminalControls(sandbox.name),
+		relativeAge({ createdAt: sandbox.createdAt, now }),
+	]);
+	const widths = columnWidths({ rows });
+
+	return [
+		chalk.dim(tableLine({ cells: HEADERS, widths, marker: "" })),
+		...rows.map((cells, index) =>
+			tableLine({
+				cells,
+				widths,
+				marker:
+					sandboxes[index]?.id === currentSandboxId
+						? chalk.dim(`${GAP}${CURRENT_MARKER}`)
+						: "",
+			}),
+		),
+	].join("\n");
+};

package/src/render/stripTerminalControls.ts

@@ -0,0 +1,19 @@
+/**
+ * ESC-initiated sequences: CSI (`ESC [ ... final`), OSC (`ESC ] ... BEL|ST`),
+ * and the two-character escapes. Matched before the bare control characters,
+ * so a whole sequence goes rather than just its ESC.
+ */
+const ESCAPE_SEQUENCE =
+	// biome-ignore lint/suspicious/noControlCharactersInRegex: matching them is the point
+	/\u001b(?:\[[\x30-\x3f]*[\x20-\x2f]*[\x40-\x7e]|\][\s\S]*?(?:\u0007|\u001b\\|$)|[\x40-\x5a\x5c-\x5f])/g;
+
+// biome-ignore lint/suspicious/noControlCharactersInRegex: C0 controls, DEL and C1
+const CONTROL_CHARACTER = /[\u0000-\u001f\u007f-\u009f]/g;
+
+/**
+ * Text a terminal prints as text. A name comes from the server, which only
+ * requires its derived slug to hold a letter or a digit, so an escape sequence
+ * in one could otherwise repaint or disguise the output around it.
+ */
+export const stripTerminalControls = (text: string): string =>
+	text.replace(ESCAPE_SEQUENCE, "").replace(CONTROL_CHARACTER, "");

package/src/repo/findRepoRoot.ts

@@ -0,0 +1,79 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, parse } from "node:path";
+
+const MONOREPO_MARKERS = [
+	"turbo.json",
+	"pnpm-workspace.yaml",
+	"pnpm-workspace.yml",
+	"lerna.json",
+	"nx.json",
+	"rush.json",
+] as const;
+
+export type RepoLayout = {
+	/** Git toplevel, else the outermost directory holding a package.json. */
+	repoRoot: string;
+	/** Nearest ancestor with a package.json — where generated files belong. */
+	packageRoot: string;
+	/** True when repoRoot shows a workspace marker and differs from packageRoot. */
+	isMonorepo: boolean;
+	/** True when the root declares workspaces at all: where init offers a package of its own. */
+	hasWorkspaces: boolean;
+};
+
+const gitToplevel = ({ cwd }: { cwd: string }): string | null => {
+	try {
+		return execFileSync("git", ["rev-parse", "--show-toplevel"], {
+			cwd,
+			encoding: "utf8",
+			stdio: ["ignore", "pipe", "ignore"],
+		}).trim();
+	} catch {
+		return null;
+	}
+};
+
+const nearestPackageDir = ({ from }: { from: string }): string | null => {
+	let current = from;
+	const { root } = parse(current);
+	while (true) {
+		if (existsSync(join(current, "package.json"))) return current;
+		if (current === root) return null;
+		current = dirname(current);
+	}
+};
+
+const declaresWorkspaces = ({ dir }: { dir: string }): boolean => {
+	const manifest = join(dir, "package.json");
+	if (!existsSync(manifest)) return false;
+	try {
+		return JSON.parse(readFileSync(manifest, "utf8")).workspaces !== undefined;
+	} catch {
+		return false;
+	}
+};
+
+/**
+ * Cheap probes, not a package-graph resolver — enough to place generated files
+ * sensibly and to tell the user which package they are pointed at.
+ */
+export const findRepoLayout = ({
+	cwd = process.cwd(),
+}: {
+	cwd?: string;
+} = {}): RepoLayout => {
+	const packageRoot = nearestPackageDir({ from: cwd }) ?? cwd;
+	const repoRoot = gitToplevel({ cwd }) ?? packageRoot;
+
+	const hasMarker =
+		MONOREPO_MARKERS.some((marker) => existsSync(join(repoRoot, marker))) ||
+		declaresWorkspaces({ dir: repoRoot });
+
+	return {
+		repoRoot,
+		packageRoot,
+		isMonorepo: hasMarker && repoRoot !== packageRoot,
+		hasWorkspaces: hasMarker,
+	};
+};

package/src/surgery/appendPropertyEdit.ts

@@ -0,0 +1,67 @@
+import type { Edit, SgNode } from "@ast-grep/napi";
+import { leadingIndentOfLine, lineStartOf } from "./fixtureEdit";
+
+const isMember = (child: SgNode): boolean =>
+	child.kind() === "pair" || child.kind() === "spread_element";
+
+/**
+ * Append a pair after the literal's last member, spreads counted. A spread
+ * that appears later overrides an earlier key at runtime, so a pair this
+ * rewriter means to take effect only wins from the end.
+ */
+export const appendPropertyEdit = ({
+	source,
+	object,
+	pair,
+}: {
+	source: string;
+	object: SgNode;
+	pair: string;
+}): Edit => {
+	const closing = object.range().end.index - 1;
+	const multiline = source
+		.slice(object.range().start.index, closing)
+		.includes("\n");
+	const members = object.children().filter(isMember);
+	const last = members[members.length - 1];
+	if (last === undefined) {
+		return multiline
+			? {
+					startPos: lineStartOf(source, closing),
+					endPos: lineStartOf(source, closing),
+					insertedText: `${leadingIndentOfLine(source, object.range().start.index)}\t${pair},\n`,
+				}
+			: {
+					startPos: object.range().start.index + 1,
+					endPos: closing,
+					insertedText: ` ${pair} `,
+				};
+	}
+	const lastEnd = last.range().end.index;
+	const between = source.slice(lastEnd, closing);
+	const trailingComma = between.trimStart().startsWith(",");
+	const afterComma = trailingComma
+		? lastEnd + between.indexOf(",") + 1
+		: lastEnd;
+	if (multiline) {
+		// Anchored to the last member itself, so a value whose closing brace shares
+		// the object's closing line can never push the insert outside the literal.
+		const indent = leadingIndentOfLine(source, last.range().start.index);
+		return {
+			startPos: afterComma,
+			endPos: afterComma,
+			insertedText: trailingComma
+				? `\n${indent}${pair},`
+				: `,\n${indent}${pair},`,
+		};
+	}
+	return {
+		startPos: afterComma,
+		endPos: afterComma,
+		insertedText: trailingComma ? ` ${pair},` : `, ${pair}`,
+	};
+};
+
+/** Whether a literal is built from a spread, so an inserted pair has to go last. */
+export const holdsSpread = ({ object }: { object: SgNode }): boolean =>
+	object.children().some((child) => child.kind() === "spread_element");

package/src/surgery/appendToArray.ts

@@ -0,0 +1,87 @@
+import type { SgNode } from "@ast-grep/napi";
+import { leadingIndentOfLine, lineStartOf } from "./fixtureEdit";
+
+/** A function is built against the indent its first line will receive. */
+export type AppendText = string | ((elementIndent: string) => string);
+
+/** Append one element to an array literal, matching its siblings' indent and
+ * comma style; an empty array is reflowed onto its own lines. */
+export const appendElementToArray = ({
+	source,
+	root,
+	array,
+	text,
+}: {
+	source: string;
+	root: SgNode;
+	array: SgNode;
+	text: AppendText;
+}): string => {
+	const elements = array.namedChildren();
+	if (elements.length === 0) {
+		const indent = leadingIndentOfLine(source, array.range().start.index);
+		// The seeded element's first line lands one tab deeper than the array.
+		const resolved = resolveText({ text, elementIndent: `${indent}\t` });
+		return root.commitEdits([
+			{
+				startPos: array.range().start.index,
+				endPos: array.range().end.index,
+				insertedText: `[\n${indent}\t${resolved},\n${indent}]`,
+			},
+		]);
+	}
+	const last = elements[elements.length - 1];
+	const lastEnd = last.range().end.index;
+	const after = source.slice(lastEnd);
+	const commaAfter = after.indexOf(",");
+	const hasTrailingComma =
+		commaAfter !== -1 && after.slice(0, commaAfter).trim() === "";
+	const insertAt = hasTrailingComma ? lastEnd + commaAfter + 1 : lastEnd;
+	const missingComma = hasTrailingComma ? "" : ",";
+	const spansLines = source
+		.slice(array.range().start.index, last.range().start.index)
+		.includes("\n");
+	if (spansLines) {
+		// Sibling indent: the whitespace opening the last element's line.
+		const indent = leadingIndentOfLine(source, last.range().start.index);
+		const resolved = resolveText({ text, elementIndent: indent });
+		return root.commitEdits([
+			{
+				startPos: insertAt,
+				endPos: insertAt,
+				insertedText: `${missingComma}\n${indent}${resolved},`,
+			},
+		]);
+	}
+	const lineIndent = leadingIndentOfLine(source, array.range().start.index);
+	const elementIndent = `${lineIndent}\t`;
+	const resolved = resolveText({ text, elementIndent });
+	if (!resolved.includes("\n")) {
+		return root.commitEdits([
+			{
+				startPos: insertAt,
+				endPos: insertAt,
+				insertedText: `${missingComma} ${resolved},`,
+			},
+		]);
+	}
+	// A one-line array cannot hold a multi-line element inline: reflow it.
+	const lines = [...elements.map((element) => element.text()), resolved].map(
+		(element) => `${elementIndent}${element},`,
+	);
+	return root.commitEdits([
+		{
+			startPos: array.range().start.index,
+			endPos: array.range().end.index,
+			insertedText: `[\n${lines.join("\n")}\n${lineIndent}]`,
+		},
+	]);
+};
+
+const resolveText = ({
+	text,
+	elementIndent,
+}: {
+	text: AppendText;
+	elementIndent: string;
+}): string => (typeof text === "function" ? text(elementIndent) : text);

package/src/surgery/appendToBinding.ts

@@ -0,0 +1,19 @@
+import { Lang, parse } from "@ast-grep/napi";
+import { type AppendText, appendElementToArray } from "./appendToArray";
+import { findArrayBinding } from "./arrayBinding";
+
+/** Append to `const name = [...]`, exported or not; null when no such array literal exists. */
+export const appendToBinding = ({
+	source,
+	name,
+	text,
+}: {
+	source: string;
+	name: string;
+	text: AppendText;
+}): string | null => {
+	const root = parse(Lang.TypeScript, source).root();
+	const array = findArrayBinding({ root, name });
+	if (array === null) return null;
+	return appendElementToArray({ source, root, array, text });
+};

package/src/surgery/appendToCollection.ts

@@ -0,0 +1,40 @@
+import type { SgNode } from "@ast-grep/napi";
+import { Lang, parse } from "@ast-grep/napi";
+import { type AppendText, appendElementToArray } from "./appendToArray";
+
+export const appendToCollection = ({
+	source,
+	collection,
+	text,
+}: {
+	source: string;
+	collection: string;
+	text: AppendText;
+}): string | null => {
+	const root = parse(Lang.TypeScript, source).root();
+	// A bare `collection: [$$$]` parses as a type annotation, so the anchor must
+	// be the enclosing atmn call; the leading/trailing $$$ allow sibling keys.
+	const anchor =
+		root.find(`atmn({ $$$, ${collection}: [$$$ITEMS], $$$ })`) ??
+		root.find(`atmn({ ${collection}: [$$$ITEMS] })`);
+	if (anchor === null) return null;
+	const array = collectionArray({ anchor, collection });
+	if (array === null) return null;
+	return appendElementToArray({ source, root, array, text });
+};
+
+const collectionArray = ({
+	anchor,
+	collection,
+}: {
+	anchor: SgNode;
+	collection: string;
+}): SgNode | null => {
+	for (const array of anchor.findAll({ rule: { kind: "array" } })) {
+		const pair = array.parent();
+		if (pair === null || pair.kind() !== "pair") continue;
+		const key = pair.namedChildren()[0];
+		if (key !== undefined && key.text() === collection) return array;
+	}
+	return null;
+};

package/src/surgery/appendToFixtureArray.ts

@@ -0,0 +1,71 @@
+import { Lang, parse } from "@ast-grep/napi";
+import { appendPropertyEdit } from "./appendPropertyEdit";
+import { type AppendText, appendElementToArray } from "./appendToArray";
+import {
+	type FixtureConstraint,
+	type FixtureShape,
+	findFixture,
+	fixtureObjectOf,
+} from "./findFixture";
+
+/**
+ * Append one element to an array property of a fixture literal
+ * (`plan({ variants: [...] })`), seeding the property when absent.
+ * Null when the fixture is not there or the property is not an array.
+ */
+export const appendToFixtureArray = ({
+	source,
+	builder,
+	idField,
+	id,
+	where,
+	property,
+	text,
+}: {
+	source: string;
+	builder: FixtureShape;
+	idField: string;
+	id: string;
+	where?: FixtureConstraint[];
+	property: string;
+	text: AppendText;
+}): string | null => {
+	const call = findFixture({
+		source,
+		builder,
+		idField,
+		id,
+		where,
+		allowDynamic: true,
+	});
+	if (call === null) return null;
+	const object = fixtureObjectOf(call);
+	if (object === null) return null;
+	const root = parse(Lang.TypeScript, source).root();
+
+	const pair = object
+		.children()
+		.find(
+			(member) =>
+				member.kind() === "pair" &&
+				member.namedChildren()[0]?.text() === property,
+		);
+	if (pair === undefined) {
+		// Seed the key, then re-find: the edit shifts every node position.
+		const seeded = root.commitEdits([
+			appendPropertyEdit({ source, object, pair: `${property}: []` }),
+		]);
+		return appendToFixtureArray({
+			source: seeded,
+			builder,
+			idField,
+			id,
+			where,
+			property,
+			text,
+		});
+	}
+	const array = pair.namedChildren()[1];
+	if (array === undefined || array.kind() !== "array") return null;
+	return appendElementToArray({ source, root, array, text });
+};

package/src/surgery/arrayBinding.ts

@@ -0,0 +1,30 @@
+import type { SgNode } from "@ast-grep/napi";
+
+/** The literal of `kind` initializing `const name` (typed or not, exported or
+ * not); null when no such declaration holds one. */
+export const findLiteralBinding = ({
+	root,
+	name,
+	kind,
+}: {
+	root: SgNode;
+	name: string;
+	kind: "array" | "object";
+}): SgNode | null => {
+	for (const declarator of root.findAll({
+		rule: { kind: "variable_declarator" },
+	})) {
+		if (declarator.field("name")?.text() !== name) continue;
+		const value = declarator.field("value");
+		if (value !== null && value.kind() === kind) return value;
+	}
+	return null;
+};
+
+export const findArrayBinding = ({
+	root,
+	name,
+}: {
+	root: SgNode;
+	name: string;
+}): SgNode | null => findLiteralBinding({ root, name, kind: "array" });

package/src/surgery/deleteFixtureLiteral.ts

@@ -0,0 +1,81 @@
+import type { SgNode } from "@ast-grep/napi";
+import { type FixtureConstraint, findFixture } from "./findFixture";
+import { lineStartOf, removeArrayElementEdits } from "./fixtureEdit";
+
+export const deleteFixtureLiteral = ({
+	source,
+	builder,
+	idField,
+	id,
+	where,
+}: {
+	source: string;
+	builder: string;
+	idField: string;
+	id: string;
+	where?: FixtureConstraint[];
+}): { source: string; exportedName?: string } | null => {
+	const call = findFixture({ source, builder, idField, id, where });
+	if (call === null) return null;
+	const root = call.getRoot().root();
+	// The nearer ancestor wins: an element of `export default atmn({ features: [
+	// ...] })` is still an array element, not an exported fixture statement.
+	let statement: SgNode | null = null;
+	let isArrayElement = false;
+	for (const ancestor of call.ancestors()) {
+		if (ancestor.kind() === "array") {
+			isArrayElement = true;
+			break;
+		}
+		if (ancestor.kind() === "export_statement") {
+			statement = ancestor;
+			break;
+		}
+	}
+	if (statement !== null && !isArrayElement) {
+		const declarator = statement.find({
+			rule: { kind: "variable_declarator" },
+		});
+		const name = declarator?.namedChildren()[0];
+		if (name === undefined || name.kind() !== "identifier") return null;
+		return {
+			source: root.commitEdits([exportRemovalEdit({ source, statement })]),
+			exportedName: name.text(),
+		};
+	}
+	const parent = call.parent();
+	if (parent === null || parent.kind() !== "array") return null;
+	const elementEdits = removeArrayElementEdits({ source, element: call });
+	if (elementEdits === null) return null;
+	return { source: root.commitEdits(elementEdits) };
+};
+
+/**
+ * Remove the whole statement line, a doc comment directly above it (exactly one
+ * newline between comment and statement), and the blank line above the comment.
+ */
+const exportRemovalEdit = ({
+	source,
+	statement,
+}: {
+	source: string;
+	statement: SgNode;
+}): { startPos: number; endPos: number; insertedText: string } => {
+	const statementLineStart = lineStartOf(source, statement.range().start.index);
+	let deleteStart = statementLineStart;
+	const comment = statement.prev();
+	if (
+		comment !== null &&
+		comment.kind() === "comment" &&
+		source.slice(comment.range().end.index, statementLineStart) === "\n"
+	) {
+		deleteStart = lineStartOf(source, comment.range().start.index);
+		const lineAbove = lineStartOf(source, deleteStart - 1);
+		if (deleteStart > 0 && source.slice(lineAbove, deleteStart).trim() === "") {
+			deleteStart = lineAbove;
+		}
+	}
+	const lineEnd = source.indexOf("\n", statement.range().end.index);
+	const deleteEnd = lineEnd === -1 ? source.length : lineEnd + 1;
+	return { startPos: deleteStart, endPos: deleteEnd, insertedText: "" };
+};

package/src/surgery/deleteReference.ts

@@ -0,0 +1,48 @@
+import type { Edit } from "@ast-grep/napi";
+import { Lang, parse } from "@ast-grep/napi";
+import {
+	importStatementOf,
+	removeArrayElementEdits,
+	removeLineEdit,
+	removeSpecifierEdit,
+} from "./fixtureEdit";
+
+export const deleteReference = ({
+	source,
+	name,
+}: {
+	source: string;
+	name: string;
+}): string => {
+	const root = parse(Lang.TypeScript, source).root();
+	const edits: Array<Edit> = [];
+	for (const identifier of root.findAll({
+		rule: { kind: "identifier", pattern: name },
+	})) {
+		const parent = identifier.parent();
+		if (parent === null || parent.kind() !== "array") continue;
+		const elementEdits = removeArrayElementEdits({
+			source,
+			element: identifier,
+		});
+		if (elementEdits !== null) edits.push(...elementEdits);
+	}
+	for (const specifier of root.findAll({
+		rule: { kind: "import_specifier" },
+	})) {
+		const names = specifier
+			.text()
+			.trim()
+			.split(/\s+as\s+/);
+		if (names[names.length - 1] !== name) continue;
+		const imports = specifier.parent();
+		if (imports !== null && imports.namedChildren().length === 1) {
+			const statement = importStatementOf(specifier);
+			if (statement !== null)
+				edits.push(removeLineEdit({ source, node: statement }));
+		} else {
+			edits.push(removeSpecifierEdit({ source, specifier }));
+		}
+	}
+	return root.commitEdits(edits);
+};