@vimhead.dev/norn-cli 0.1.0-tip.35614826665.1 → 0.1.0-tip.35724621678.1

package/assets/packages/cli/src/client.ts

@@ -27,13 +27,22 @@ export type NornClient = {
 		inspect(): Promise<NornProjectInspection>;
 	};
 	readonly workflows: {
-		list(options?: { readonly all?: boolean }): Promise<NornWorkflowCatalogInfo>;
+		list(options?: {
+			readonly all?: boolean;
+		}): Promise<NornWorkflowCatalogInfo>;
 		inspect(workflowId: string): Promise<NornWorkflowInspection>;
 		entries(): Promise<readonly NornRegisteredWorkflow[]>;
 	};
 	readonly runs: {
-		start(input: { readonly workflowId: string; readonly args: unknown; readonly configOverride?: unknown }): Promise<NornRunInfo>;
-		resume(input: { readonly run: string; readonly args?: unknown }): Promise<NornRunInfo>;
+		start(input: {
+			readonly workflowId: string;
+			readonly args: unknown;
+			readonly configOverride?: unknown;
+		}): Promise<NornRunInfo>;
+		resume(input: {
+			readonly run: string;
+			readonly args?: unknown;
+		}): Promise<NornRunInfo>;
 		wait(run: string): Promise<NornRunInfo>;
 		list(): Promise<NornRunInfo[]>;
 		inspect(run: string): Promise<NornRunInfo>;
@@ -43,7 +52,10 @@ export type NornClient = {
 		stop(run: string): Promise<NornRunInfo>;
 		kill(run: string): Promise<NornRunInfo>;
 		delete(run: string): Promise<DeletedNornRunInfo>;
-		logs(run: string, options?: { readonly follow?: boolean }): AsyncIterable<Record<string, unknown>>;
+		logs(
+			run: string,
+			options?: { readonly follow?: boolean },
+		): AsyncIterable<Record<string, unknown>>;
 	};
 };
 
@@ -52,26 +64,118 @@ export function createNornClient(input: NornClientInput = {}): NornClient {
 	const catalog = new NornWorkflowCatalog(input.spawnCwd ?? process.cwd());
 	const client: NornClient = {
 		project: {
-			inspect: async () => processRunner.readJson<NornProjectInspection>(["project", "inspect"]),
+			inspect: async () =>
+				processRunner.readJson<NornProjectInspection>(["project", "inspect"]),
 		},
 		workflows: {
-			list: async (options) => processRunner.readJson<NornWorkflowCatalogInfo>(["workflows", "list", ...(options?.all ? ["--all"] : [])]),
-			inspect: async (workflowId) => processRunner.readJson<NornWorkflowInspection>(["workflows", "inspect", workflowId]),
+			list: async (options) =>
+				processRunner.readJson<NornWorkflowCatalogInfo>([
+					"workflows",
+					"list",
+					...(options?.all ? ["--all"] : []),
+				]),
+			inspect: async (workflowId) =>
+				processRunner.readJson<NornWorkflowInspection>([
+					"workflows",
+					"inspect",
+					workflowId,
+				]),
 			entries: async () => (await catalog.load()).workflows,
 		},
 		runs: {
-			start: async (startInput) => (await processRunner.readJson<{ run: NornRunInfo }>(["runs", "start", startInput.workflowId], JSON.stringify(runStartInput(startInput)))).run,
-			resume: async (resumeInput) => (await processRunner.readJson<{ run: NornRunInfo }>(["runs", "resume", resumeInput.run], runResumeStdin(resumeInput))).run,
-			wait: async (run) => (await processRunner.readJson<{ run: NornRunInfo }>(["runs", "wait", run])).run,
-			list: async () => (await processRunner.readJson<{ runs: NornRunInfo[] }>(["runs", "list"])).runs,
-			inspect: async (run) => (await processRunner.readJson<{ run: NornRunInfo }>(["runs", "inspect", run])).run,
-			checkpoints: async (run) => (await processRunner.readJson<{ checkpoints: NornRunCheckpoint[] }>(["runs", "checkpoints", run])).checkpoints,
-			metrics: async (run) => (await processRunner.readJson<{ metrics: NornRunMetrics }>(["runs", "metrics", run])).metrics,
-			rollback: async (run, checkpointId) => (await processRunner.readJson<{ run: NornRunInfo }>(["runs", "rollback", run, checkpointId])).run,
-			stop: async (run) => (await processRunner.readJson<{ run: NornRunInfo }>(["runs", "stop", run])).run,
-			kill: async (run) => (await processRunner.readJson<{ run: NornRunInfo }>(["runs", "kill", run])).run,
-			delete: async (run) => (await processRunner.readJson<{ deleted: DeletedNornRunInfo }>(["runs", "delete", run])).deleted,
-			logs: (run, options) => processRunner.readJsonLines(["runs", "logs", run, ...(options?.follow ? ["--follow"] : [])]),
+			start: async (startInput) =>
+				(
+					await processRunner.readJson<{ run: NornRunInfo }>(
+						["runs", "start", startInput.workflowId],
+						JSON.stringify(runStartInput(startInput)),
+					)
+				).run,
+			resume: async (resumeInput) =>
+				(
+					await processRunner.readJson<{ run: NornRunInfo }>(
+						["runs", "resume", resumeInput.run],
+						runResumeStdin(resumeInput),
+					)
+				).run,
+			wait: async (run) =>
+				(
+					await processRunner.readJson<{ run: NornRunInfo }>([
+						"runs",
+						"wait",
+						run,
+					])
+				).run,
+			list: async () =>
+				(
+					await processRunner.readJson<{ runs: NornRunInfo[] }>([
+						"runs",
+						"list",
+					])
+				).runs,
+			inspect: async (run) =>
+				(
+					await processRunner.readJson<{ run: NornRunInfo }>([
+						"runs",
+						"inspect",
+						run,
+					])
+				).run,
+			checkpoints: async (run) =>
+				(
+					await processRunner.readJson<{ checkpoints: NornRunCheckpoint[] }>([
+						"runs",
+						"checkpoints",
+						run,
+					])
+				).checkpoints,
+			metrics: async (run) =>
+				(
+					await processRunner.readJson<{ metrics: NornRunMetrics }>([
+						"runs",
+						"metrics",
+						run,
+					])
+				).metrics,
+			rollback: async (run, checkpointId) =>
+				(
+					await processRunner.readJson<{ run: NornRunInfo }>([
+						"runs",
+						"rollback",
+						run,
+						checkpointId,
+					])
+				).run,
+			stop: async (run) =>
+				(
+					await processRunner.readJson<{ run: NornRunInfo }>([
+						"runs",
+						"stop",
+						run,
+					])
+				).run,
+			kill: async (run) =>
+				(
+					await processRunner.readJson<{ run: NornRunInfo }>([
+						"runs",
+						"kill",
+						run,
+					])
+				).run,
+			delete: async (run) =>
+				(
+					await processRunner.readJson<{ deleted: DeletedNornRunInfo }>([
+						"runs",
+						"delete",
+						run,
+					])
+				).deleted,
+			logs: (run, options) =>
+				processRunner.readJsonLines([
+					"runs",
+					"logs",
+					run,
+					...(options?.follow ? ["--follow"] : []),
+				]),
 		},
 	};
 	return client;
@@ -83,7 +187,7 @@ class NornWorkflowCatalog {
 	constructor(private readonly cwd: string) {}
 
 	load(): ReturnType<typeof loadNornProject> {
-		this.loaded ??= loadNornProject(this.cwd).catch(error => {
+		this.loaded ??= loadNornProject(this.cwd).catch((error) => {
 			this.loaded = undefined;
 			throw error;
 		});
@@ -95,22 +199,46 @@ class NornProcessRunner {
 	private readonly executablePath: string;
 
 	constructor(private readonly input: NornClientInput) {
-		this.executablePath = input.executablePath ?? fileURLToPath(new URL("../bin/norn.mjs", import.meta.url));
+		this.executablePath =
+			input.executablePath ??
+			fileURLToPath(new URL("../bin/norn.mjs", import.meta.url));
 	}
 
 	async readJson<T>(args: readonly string[], stdin?: string): Promise<T> {
 		const result = await this.spawn(args, stdin);
-		const parsed = JSON.parse(result.stdout) as T | { error?: { code?: string; message?: string; diagnostics?: NornWorkflowDiagnostic[] } };
+		const parsed = JSON.parse(result.stdout) as
+			| T
+			| {
+					error?: {
+						code?: string;
+						message?: string;
+						diagnostics?: NornWorkflowDiagnostic[];
+					};
+			  };
 		if (parsed && typeof parsed === "object" && "error" in parsed) {
-			if (parsed.error?.code === "NORN_PROJECT_INVALID" && Array.isArray(parsed.error.diagnostics)) throw new NornProjectLoadError({ diagnostics: parsed.error.diagnostics });
+			if (
+				parsed.error?.code === "NORN_PROJECT_INVALID" &&
+				Array.isArray(parsed.error.diagnostics)
+			)
+				throw new NornProjectLoadError({
+					diagnostics: parsed.error.diagnostics,
+				});
 			throw new Error(parsed.error?.message ?? "Norn command failed");
 		}
-		if (result.exitCode !== 0) throw new Error(result.stderr || `Norn exited with code ${result.exitCode}`);
+		if (result.exitCode !== 0)
+			throw new Error(
+				result.stderr || `Norn exited with code ${result.exitCode}`,
+			);
 		return parsed as T;
 	}
 
-	async *readJsonLines(args: readonly string[]): AsyncIterable<Record<string, unknown>> {
-		const child = spawn(process.execPath, [this.executablePath, ...args], { cwd: this.input.spawnCwd, stdio: ["ignore", "pipe", "pipe"] });
+	async *readJsonLines(
+		args: readonly string[],
+	): AsyncIterable<Record<string, unknown>> {
+		const child = spawn(process.execPath, [this.executablePath, ...args], {
+			cwd: this.input.spawnCwd,
+			stdio: ["ignore", "pipe", "pipe"],
+		});
 		let stderr = "";
 		child.stderr?.on("data", (chunk) => {
 			stderr += chunk.toString();
@@ -119,16 +247,35 @@ class NornProcessRunner {
 		for await (const line of lines) {
 			if (line.trim().length === 0) continue;
 			const parsed = JSON.parse(line) as Record<string, unknown>;
-			if (parsed.error) throw new Error(String((parsed.error as { message?: unknown }).message ?? "Norn stream failed"));
+			if (parsed.error)
+				throw new Error(
+					String(
+						(parsed.error as { message?: unknown }).message ??
+							"Norn stream failed",
+					),
+				);
 			yield parsed;
 		}
-		const exitCode = await new Promise<number | null>((resolvePromise) => child.on("close", resolvePromise));
-		if (exitCode !== 0) throw new Error(stderr || `Norn exited with code ${exitCode}`);
+		const exitCode = await new Promise<number | null>((resolvePromise) =>
+			child.on("close", resolvePromise),
+		);
+		if (exitCode !== 0)
+			throw new Error(stderr || `Norn exited with code ${exitCode}`);
 	}
 
-	private async spawn(args: readonly string[], stdin?: string): Promise<{ readonly stdout: string; readonly stderr: string; readonly exitCode: number | null }> {
+	private async spawn(
+		args: readonly string[],
+		stdin?: string,
+	): Promise<{
+		readonly stdout: string;
+		readonly stderr: string;
+		readonly exitCode: number | null;
+	}> {
 		return new Promise((resolvePromise, reject) => {
-			const child = spawn(process.execPath, [this.executablePath, ...args], { cwd: this.input.spawnCwd, stdio: [stdin === undefined ? "ignore" : "pipe", "pipe", "pipe"] });
+			const child = spawn(process.execPath, [this.executablePath, ...args], {
+				cwd: this.input.spawnCwd,
+				stdio: [stdin === undefined ? "ignore" : "pipe", "pipe", "pipe"],
+			});
 			let stdout = "";
 			let stderr = "";
 			child.stdout?.on("data", (chunk) => {
@@ -139,15 +286,26 @@ class NornProcessRunner {
 			});
 			child.on("error", reject);
 			if (stdin !== undefined) child.stdin?.end(stdin);
-			child.on("close", (exitCode) => resolvePromise({ stdout, stderr, exitCode }));
+			child.on("close", (exitCode) =>
+				resolvePromise({ stdout, stderr, exitCode }),
+			);
 		});
 	}
 }
 
-function runStartInput(input: { readonly args: unknown; readonly configOverride?: unknown }): { readonly args: unknown; readonly config?: unknown } {
-	return input.configOverride === undefined ? { args: input.args } : { args: input.args, config: input.configOverride };
+function runStartInput(input: {
+	readonly args: unknown;
+	readonly configOverride?: unknown;
+}): { readonly args: unknown; readonly config?: unknown } {
+	return input.configOverride === undefined
+		? { args: input.args }
+		: { args: input.args, config: input.configOverride };
 }
 
-function runResumeStdin(input: { readonly args?: unknown }): string | undefined {
-	return input.args === undefined ? undefined : JSON.stringify({ args: input.args });
+function runResumeStdin(input: {
+	readonly args?: unknown;
+}): string | undefined {
+	return input.args === undefined
+		? undefined
+		: JSON.stringify({ args: input.args });
 }

package/assets/packages/cli/src/documentation.ts

@@ -1,8 +1,22 @@
 import { createHash } from "node:crypto";
-import { lstat, mkdir, mkdtemp, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import {
+	lstat,
+	mkdir,
+	mkdtemp,
+	readFile,
+	readdir,
+	rename,
+	rm,
+	writeFile,
+} from "node:fs/promises";
 import { join, resolve } from "node:path";
 import type { NornBuildInfo } from "./build-info.ts";
-import { DOCUMENTATION_PATHS, hashDocumentationBundle, validateDocumentationBundle, type NornDocumentationBundle } from "./internal/documentation-bundle.ts";
+import {
+	DOCUMENTATION_PATHS,
+	hashDocumentationBundle,
+	validateDocumentationBundle,
+	type NornDocumentationBundle,
+} from "./internal/documentation-bundle.ts";
 import { isNodeError } from "@vimhead.dev/norn-core/errors";
 
 export { renderNornDocumentationIntro } from "./documentation-intro.ts";
@@ -16,7 +30,13 @@ export type NornDocumentationLocation = {
 	readonly version: string;
 	readonly commit: string | null;
 	readonly assetDigest: string | null;
-	readonly paths: { readonly root: string; readonly readme: string; readonly index: string; readonly docs: string; readonly examples: string };
+	readonly paths: {
+		readonly root: string;
+		readonly readme: string;
+		readonly index: string;
+		readonly docs: string;
+		readonly examples: string;
+	};
 };
 
 export function resolveDocumentationCacheRoot(input: {
@@ -26,10 +46,20 @@ export function resolveDocumentationCacheRoot(input: {
 }): string {
 	const override = input.environment.NORN_DOCS_CACHE_DIR;
 	if (override) return resolve(override);
-	if (input.platform === "win32") return join(input.environment.LOCALAPPDATA || join(input.home, "AppData", "Local"), "norn", "docs");
-	if (input.platform === "darwin") return join(input.home, "Library", "Caches", "norn", "docs");
+	if (input.platform === "win32")
+		return join(
+			input.environment.LOCALAPPDATA || join(input.home, "AppData", "Local"),
+			"norn",
+			"docs",
+		);
+	if (input.platform === "darwin")
+		return join(input.home, "Library", "Caches", "norn", "docs");
 	const xdgCache = input.environment.XDG_CACHE_HOME;
-	return join(xdgCache?.startsWith("/") ? xdgCache : join(input.home, ".cache"), "norn", "docs");
+	return join(
+		xdgCache?.startsWith("/") ? xdgCache : join(input.home, ".cache"),
+		"norn",
+		"docs",
+	);
 }
 
 export async function resolveNornDocumentation(input: {
@@ -42,18 +72,43 @@ export async function resolveNornDocumentation(input: {
 	let assetDigest: string | null = null;
 	if (input.source.kind === "local") {
 		root = resolve(input.source.root);
-		const packageInfo = JSON.parse(await readFile(join(root, "package.json"), "utf8")) as { version?: unknown };
-		if (typeof packageInfo.version !== "string" || packageInfo.version.length === 0) throw new Error("Invalid documentation package version");
+		const packageInfo = JSON.parse(
+			await readFile(join(root, "package.json"), "utf8"),
+		) as { version?: unknown };
+		if (
+			typeof packageInfo.version !== "string" ||
+			packageInfo.version.length === 0
+		)
+			throw new Error("Invalid documentation package version");
 		version = packageInfo.version;
-		if (version !== input.build.version) throw new Error("Local documentation version does not match the runtime; rebuild or reinstall this CLI package");
+		if (version !== input.build.version)
+			throw new Error(
+				"Local documentation version does not match the runtime; rebuild or reinstall this CLI package",
+			);
 		await validateLocalDocumentation(root);
 	} else {
 		validateDocumentationBundle(input.source.bundle);
 		version = input.source.bundle.version;
-		if (version !== input.build.version) throw new Error("Embedded documentation version does not match the binary build");
+		if (version !== input.build.version)
+			throw new Error(
+				"Embedded documentation version does not match the binary build",
+			);
 		assetDigest = hashDocumentationBundle(input.source.bundle);
-		const cacheKey = createHash("sha256").update(JSON.stringify({ format: 1, assetDigest, version, commit: input.build.commit })).digest("hex");
-		root = await new NornDocumentationCache({ cacheRoot: resolve(input.cacheRoot), cacheKey, bundle: input.source.bundle }).materialize();
+		const cacheKey = createHash("sha256")
+			.update(
+				JSON.stringify({
+					format: 1,
+					assetDigest,
+					version,
+					commit: input.build.commit,
+				}),
+			)
+			.digest("hex");
+		root = await new NornDocumentationCache({
+			cacheRoot: resolve(input.cacheRoot),
+			cacheKey,
+			bundle: input.source.bundle,
+		}).materialize();
 	}
 	return {
 		storage: input.source.kind === "local" ? "installation" : "cache",
@@ -73,8 +128,10 @@ export async function resolveNornDocumentation(input: {
 async function validateLocalDocumentation(root: string): Promise<void> {
 	for (const [key, path] of Object.entries(DOCUMENTATION_PATHS)) {
 		const stat = await lstat(join(root, path));
-		const isExpectedType = key === "docs" || key === "examples" ? stat.isDirectory() : stat.isFile();
-		if (!isExpectedType) throw new Error(`Invalid local documentation path: ${join(root, path)}`);
+		const isExpectedType =
+			key === "docs" || key === "examples" ? stat.isDirectory() : stat.isFile();
+		if (!isExpectedType)
+			throw new Error(`Invalid local documentation path: ${join(root, path)}`);
 	}
 }
 
@@ -82,30 +139,55 @@ class NornDocumentationCache {
 	private readonly root: string;
 	private readonly files: ReadonlyMap<string, string>;
 
-	constructor(private readonly input: { readonly cacheRoot: string; readonly cacheKey: string; readonly bundle: NornDocumentationBundle }) {
+	constructor(
+		private readonly input: {
+			readonly cacheRoot: string;
+			readonly cacheKey: string;
+			readonly bundle: NornDocumentationBundle;
+		},
+	) {
 		this.root = join(input.cacheRoot, `v1-${input.cacheKey}`);
-		this.files = new Map(input.bundle.files.map(file => [file.path, file.content]));
+		this.files = new Map(
+			input.bundle.files.map((file) => [file.path, file.content]),
+		);
 	}
 
 	async materialize(): Promise<string> {
 		await mkdir(this.input.cacheRoot, { recursive: true, mode: 0o700 });
 		const cacheStat = await lstat(this.input.cacheRoot);
-		if (!cacheStat.isDirectory() || cacheStat.isSymbolicLink()) throw new Error(`Documentation cache root must be a real directory: ${this.input.cacheRoot}`);
+		if (!cacheStat.isDirectory() || cacheStat.isSymbolicLink())
+			throw new Error(
+				`Documentation cache root must be a real directory: ${this.input.cacheRoot}`,
+			);
 		if (await this.validateExistingCache()) return this.root;
 		const staging = await mkdtemp(join(this.input.cacheRoot, ".extract-"));
 		try {
 			for (const file of this.input.bundle.files) {
 				const parts = file.path.split("/");
-				await mkdir(join(staging, ...parts.slice(0, -1)), { recursive: true, mode: 0o700 });
-				await writeFile(join(staging, ...parts), file.content, { encoding: "utf8", flag: "wx", mode: 0o600 });
+				await mkdir(join(staging, ...parts.slice(0, -1)), {
+					recursive: true,
+					mode: 0o700,
+				});
+				await writeFile(join(staging, ...parts), file.content, {
+					encoding: "utf8",
+					flag: "wx",
+					mode: 0o600,
+				});
 			}
 			try {
 				await rename(staging, this.root);
 			} catch (error) {
-				if (!isNodeError(error) || !["EEXIST", "ENOTEMPTY", "EPERM", "EACCES"].includes(error.code ?? "")) throw error;
-				if (!await this.validateExistingCache()) throw error;
+				if (
+					!isNodeError(error) ||
+					!["EEXIST", "ENOTEMPTY", "EPERM", "EACCES"].includes(error.code ?? "")
+				)
+					throw error;
+				if (!(await this.validateExistingCache())) throw error;
 			}
-			if (!await this.validateExistingCache()) throw new Error(`Documentation cache disappeared after extraction: ${this.root}`);
+			if (!(await this.validateExistingCache()))
+				throw new Error(
+					`Documentation cache disappeared after extraction: ${this.root}`,
+				);
 			return this.root;
 		} finally {
 			await rm(staging, { recursive: true, force: true });
@@ -120,22 +202,43 @@ class NornDocumentationCache {
 			if (isNodeError(error) && error.code === "ENOENT") return false;
 			throw error;
 		}
-		if (!stat.isDirectory() || stat.isSymbolicLink()) throw this.invalidCacheError();
+		if (!stat.isDirectory() || stat.isSymbolicLink())
+			throw this.invalidCacheError();
 		const seenFiles = new Set<string>();
-		await this.validateDirectory({ directory: this.root, prefix: "", seenFiles });
+		await this.validateDirectory({
+			directory: this.root,
+			prefix: "",
+			seenFiles,
+		});
 		if (seenFiles.size !== this.files.size) throw this.invalidCacheError();
 		return true;
 	}
 
-	private async validateDirectory(input: { readonly directory: string; readonly prefix: string; readonly seenFiles: Set<string> }): Promise<void> {
-		for (const entry of await readdir(input.directory, { withFileTypes: true })) {
+	private async validateDirectory(input: {
+		readonly directory: string;
+		readonly prefix: string;
+		readonly seenFiles: Set<string>;
+	}): Promise<void> {
+		for (const entry of await readdir(input.directory, {
+			withFileTypes: true,
+		})) {
 			const path = input.prefix ? `${input.prefix}/${entry.name}` : entry.name;
 			const absolutePath = join(input.directory, entry.name);
 			if (entry.isDirectory()) {
-				if (![...this.files.keys()].some(file => file.startsWith(`${path}/`))) throw this.invalidCacheError();
-				await this.validateDirectory({ directory: absolutePath, prefix: path, seenFiles: input.seenFiles });
+				if (![...this.files.keys()].some((file) => file.startsWith(`${path}/`)))
+					throw this.invalidCacheError();
+				await this.validateDirectory({
+					directory: absolutePath,
+					prefix: path,
+					seenFiles: input.seenFiles,
+				});
 			} else if (entry.isFile() && this.files.has(path)) {
-				if (!(await readFile(absolutePath)).equals(Buffer.from(this.files.get(path)!, "utf8"))) throw this.invalidCacheError();
+				if (
+					!(await readFile(absolutePath)).equals(
+						Buffer.from(this.files.get(path)!, "utf8"),
+					)
+				)
+					throw this.invalidCacheError();
 				input.seenFiles.add(path);
 			} else {
 				throw this.invalidCacheError();
@@ -144,6 +247,8 @@ class NornDocumentationCache {
 	}
 
 	private invalidCacheError(): Error {
-		return new Error(`Documentation cache is incomplete or modified: ${this.root}. Remove this cache entry and retry; copy examples elsewhere before editing them.`);
+		return new Error(
+			`Documentation cache is incomplete or modified: ${this.root}. Remove this cache entry and retry; copy examples elsewhere before editing them.`,
+		);
 	}
 }

package/assets/packages/cli/src/generated-build-info.ts

@@ -2,8 +2,8 @@ import type { NornBuildInfo } from "./build-info.ts";
 
 export const NORN_GENERATED_BUILD_INFO = {
   "kind": "npm-registry",
-  "version": "0.1.0-tip.35614826665.1",
-  "commit": "286e68533b1d26b5afbb0cba9d75f857fb85dc53",
+  "version": "0.1.0-tip.35724621678.1",
+  "commit": "51ea925604755506d4cde05b9224eacb48189ffd",
   "packageSpec": "@vimhead.dev/norn-cli@tip",
   "upgrade": {
     "supported": false,

package/assets/packages/cli/src/internal/agent-directory.ts

@@ -1,5 +1,10 @@
 import { join, resolve } from "node:path";
 
-export function resolveNornAgentDirectory(input: { home: string; environment: NodeJS.ProcessEnv }): string {
-	return resolve(input.environment.NORN_AGENT_DIR || join(input.home, ".norn", "agent"));
+export function resolveNornAgentDirectory(input: {
+	home: string;
+	environment: NodeJS.ProcessEnv;
+}): string {
+	return resolve(
+		input.environment.NORN_AGENT_DIR || join(input.home, ".norn", "agent"),
+	);
 }