@decohere/devkit 0.0.1-dev.126 → 0.0.1-dev.5

package/{types/src/interop/git/git.types.d.ts → src/interop/git/git.types.ts}

@@ -1,14 +1,17 @@
 export type GitOptions = {
-    cwd?: string;
+	cwd?: string;
 };
+
 export type CommitOptions = {
-    files?: string[];
-    all?: boolean;
+	files?: string[];
+	all?: boolean;
 } & GitOptions;
+
 export type PushOptions = {
-    setUpstream: string;
+	setUpstream: string;
 } & GitOptions;
+
 export type StageOptions = {
-    files?: string[];
-    all?: string;
+	files?: string[];
+	all?: string;
 };

package/{es6/src/interop/index.js → src/interop/index.ts}

@@ -1,4 +1,5 @@
 // << Git >>
+
 // << Docker >>
 export * from "./docker/docker.js";
 export * from "./git/git.js";

package/src/interop/node/node.ts

@@ -0,0 +1,38 @@
+import { type SpawnOptions, spawn } from "node:child_process";
+import { Shell } from "../shell/shell.js";
+
+export class Node extends Shell {
+	protected program: string = "node";
+
+	public async runScript(script: string, ...args: string[]) {
+		const spawnOpt: SpawnOptions = {
+			cwd: ".",
+			stdio: "inherit",
+			env: {
+				...process.env,
+			},
+		};
+
+		return new Promise((resolve, reject) => {
+			const proc = spawn("node", [script, ...args], spawnOpt);
+
+			proc.on("exit", (code) => {
+				if (code !== 0) {
+					reject();
+				}
+
+				resolve(null);
+			});
+
+			proc.on("close", (code) => {
+				resolve(null);
+				if (code === 0) {
+					resolve({
+						message: `${script} completed`,
+					});
+				}
+				reject(`Running '${script}' failed with code ${code}`);
+			});
+		});
+	}
+}

package/src/interop/npm/npm.ts

@@ -0,0 +1,168 @@
+import { InteropError } from "../errors/interop.error.js";
+import { Shell } from "../shell/shell.js";
+import type { PackageManager } from "../types/package-manager.js";
+import type { NpmOptions, PublishOptions, VersionOptions, VersionType } from "./npm.types.js";
+
+const Commands = {
+	publish: "publish",
+	version: "version",
+	link: "link",
+	install: "install",
+};
+
+export class Npm extends Shell implements PackageManager {
+	public readonly name = "npm" as const;
+	protected program: string = "npm";
+
+	public async publish(directory: string, options: PublishOptions = { channel: "beta" }) {
+		const { cwd, dryRun, skipIfPublished, channel, authToken, otp, provenance } = options;
+		if (directory == null) {
+			throw new InteropError("Directory is required");
+		}
+
+		if (skipIfPublished && !dryRun) {
+			const alreadyPublished = await this.isPublished(directory, { cwd });
+			if (alreadyPublished) {
+				return { message: `Skipping publish — version already exists on registry`, data: [] };
+			}
+		}
+
+		const args = [Commands.publish, directory];
+		let tmpUserConfigPath: string | undefined;
+
+		args.push("--tag", channel ?? "beta");
+
+		if (provenance) {
+			args.push("--provenance");
+		}
+
+		// Explicit --token (local bootstrap). OIDC publish must not inherit cwd .npmrc / NODE_AUTH_TOKEN.
+		if (authToken?.trim()) {
+			tmpUserConfigPath = await this.createTempUserConfig(authToken.trim());
+			args.push("--userconfig", tmpUserConfigPath);
+		}
+
+		if (dryRun) {
+			args.push("--dry-run");
+		}
+
+		const env = { ...process.env };
+		if (!authToken?.trim()) {
+			delete env.NODE_AUTH_TOKEN;
+			delete env.NPM_TOKEN;
+			env.NPM_CONFIG_USERCONFIG = "/dev/null";
+		}
+		if (otp) {
+			env.NPM_CONFIG_OTP = otp;
+		}
+
+		try {
+			return await this.run({ cwd, env }, ...args);
+		} catch (error) {
+			if (skipIfPublished && !dryRun && isAlreadyPublishedError(error)) {
+				return { message: `Skipping publish — version already exists on registry`, data: [] };
+			}
+			throw error;
+		} finally {
+			if (tmpUserConfigPath) {
+				await this.removeTempUserConfig(tmpUserConfigPath);
+			}
+		}
+	}
+
+	/**
+	 * @description Runs in the directory of the package
+	 * @param options
+	 * @returns
+	 */
+	public async version(versionType: VersionType, options: VersionOptions) {
+		const { cwd, noTag, preid } = options;
+		const args = [Commands.version, versionType];
+		if (noTag) {
+			args.push("--no-git-tag-version");
+		}
+
+		if (preid) {
+			args.push("--preid", preid);
+		}
+
+		return this.run({ cwd }, ...args);
+	}
+
+	public async link(directory: string, options: NpmOptions = { cwd: "./" }) {
+		const { cwd } = options;
+		const args = [Commands.link, directory];
+		return this.run({ cwd }, ...args);
+	}
+
+	public async install(options: NpmOptions = { cwd: "./" }) {
+		const { cwd } = options;
+		return this.run({ cwd }, Commands.install);
+	}
+
+	/**
+	 * Install only `dependencies` as real folders: `--omit=dev` skips devDependencies and
+	 * `--no-bin-links` skips the `.bin` symlinks, so the result holds no symlinks at all.
+	 */
+	public async installProduction(options: NpmOptions = { cwd: "./" }) {
+		const { cwd } = options;
+		return this.run(
+			{ cwd },
+			Commands.install,
+			"--omit=dev",
+			"--no-bin-links",
+			"--no-audit",
+			"--no-fund",
+			"--loglevel=error",
+		);
+	}
+
+	public async syncLockFile(options: NpmOptions = { cwd: "./" }) {
+		const { cwd } = options;
+		return this.run({ cwd }, Commands.install, "--package-lock-only", "--ignore-scripts");
+	}
+
+	/**
+	 * True when package@version exists on the registry.
+	 * Uses ambient npm config (cwd `.npmrc`); do not pass tokens on argv.
+	 */
+	private async isPublished(directory: string, options: NpmOptions): Promise<boolean> {
+		const { readFileSync } = await import("node:fs");
+		const { join } = await import("node:path");
+		try {
+			const pkgJson = JSON.parse(readFileSync(join(directory, "package.json"), "utf8"));
+			const spec = `${pkgJson.name}@${pkgJson.version}`;
+			await this.run(options, "view", spec, "version");
+			return true;
+		} catch {
+			return false;
+		}
+	}
+
+	private async createTempUserConfig(authToken: string): Promise<string> {
+		const { mkdtemp, writeFile } = await import("node:fs/promises");
+		const { tmpdir } = await import("node:os");
+		const { join } = await import("node:path");
+		const tempDir = await mkdtemp(join(tmpdir(), "decohere-npmrc-"));
+		const npmrcPath = join(tempDir, ".npmrc");
+		const npmrc = [
+			"registry=https://registry.npmjs.org/",
+			"always-auth=true",
+			`//registry.npmjs.org/:_authToken=${authToken}`,
+		].join("\n");
+		await writeFile(npmrcPath, `${npmrc}\n`, { mode: 0o600 });
+		return npmrcPath;
+	}
+
+	private async removeTempUserConfig(npmrcPath: string): Promise<void> {
+		const { rm } = await import("node:fs/promises");
+		const { dirname } = await import("node:path");
+		const dir = dirname(npmrcPath);
+		await rm(dir, { recursive: true, force: true });
+	}
+}
+
+function isAlreadyPublishedError(error: unknown): boolean {
+	const message = error instanceof Error ? error.message : String(error);
+	return /cannot publish over the previously published versions/i.test(message);
+}

package/src/interop/npm/npm.types.ts

@@ -0,0 +1,28 @@
+export type NpmOptions = {
+	cwd?: string;
+};
+
+export type PublishOptions = {
+	dryRun?: boolean;
+	skipIfPublished?: boolean;
+	authToken?: string;
+	otp?: string;
+	provenance?: boolean;
+	/** @deprecated use channel */
+	versionType?: VersionType;
+	channel?: string;
+} & NpmOptions;
+
+export type VersionType = "major" | "minor" | "patch" | "prerelease";
+
+export const VersionTypes = {
+	major: "major",
+	minor: "minor",
+	patch: "patch",
+	prerelease: "prerelease",
+} satisfies Record<VersionType, VersionType>;
+
+export type VersionOptions = {
+	preid?: string;
+	noTag?: boolean;
+} & NpmOptions;

package/src/interop/pnpm/pnpm.ts

@@ -0,0 +1,22 @@
+import { Shell } from "../shell/shell.js";
+import type { PackageManager } from "../types/package-manager.js";
+import type { PnpmOptions } from "./pnpm.types.js";
+
+const Commands = {
+	install: "install",
+};
+
+export class Pnpm extends Shell implements PackageManager {
+	public readonly name = "pnpm" as const;
+	protected program: string = "pnpm";
+
+	public async install(options: PnpmOptions = { cwd: "./" }) {
+		const { cwd } = options;
+		return this.run({ cwd }, Commands.install);
+	}
+
+	public async syncLockFile(options: PnpmOptions = { cwd: "./" }) {
+		const { cwd } = options;
+		return this.run({ cwd }, Commands.install, "--lockfile-only", "--ignore-scripts");
+	}
+}

package/{types/src/interop/pnpm/pnpm.types.d.ts → src/interop/pnpm/pnpm.types.ts}

@@ -1,3 +1,3 @@
 export type PnpmOptions = {
-    cwd?: string;
+	cwd?: string;
 };

package/src/interop/shell/shell.argv.ts

@@ -0,0 +1,31 @@
+function fields(args: string[]): Record<string, string | boolean | string[]> {
+	const positional: string[] = [];
+	const flags: Record<string, string | boolean> = {};
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--") {
+			positional.push(...args.slice(i + 1));
+			break;
+		}
+		if (arg.startsWith("--")) {
+			const body = arg.slice(2);
+			const eq = body.indexOf("=");
+			if (eq !== -1) {
+				flags[body.slice(0, eq)] = body.slice(eq + 1);
+				continue;
+			}
+			const next = args[i + 1];
+			if (next != null && !next.startsWith("-")) {
+				flags[body] = next;
+				i += 1;
+			} else {
+				flags[body] = true;
+			}
+			continue;
+		}
+		positional.push(arg);
+	}
+	return { _: positional, ...flags };
+}
+
+export const shellArgv = { fields };

package/src/interop/shell/shell.ts

@@ -0,0 +1,100 @@
+import { type SpawnOptions, spawn } from "node:child_process";
+import { scribe } from "@decohere/scribe";
+import { InteropError } from "../errors/interop.error.js";
+import { shellArgv } from "./shell.argv.js";
+import type { ShellOptions, ShellResponse } from "./shell.types.js";
+
+export abstract class Shell {
+	protected abstract program: string;
+	protected async run(options: ShellOptions, ...args: string[]) {
+		const logger = scribe.logger(Shell.name);
+		const argv = args ?? [];
+		const argvFields = shellArgv.fields(argv);
+		const positionals = Array.isArray(argvFields._) ? argvFields._ : [];
+		const commandName = [this.program, ...positionals].join(" ").trim();
+		logger.info("Running", { program: this.program, args: argvFields });
+		return new Promise<ShellResponse>((resolve, reject) => {
+			let settled = false;
+			const resolveOnce = (response: ShellResponse) => {
+				if (settled) {
+					return;
+				}
+				settled = true;
+				resolve(response);
+			};
+
+			const rejectOnce = (error: unknown) => {
+				if (settled) {
+					return;
+				}
+				settled = true;
+				reject(error);
+			};
+
+			const { cwd, env } = options;
+			const spawnOpt: SpawnOptions = {
+				cwd: cwd ?? ".",
+				stdio: ["inherit", "pipe", "pipe"],
+				env: env ?? { ...process.env },
+			};
+
+			const proc = spawn(this.program, argv, spawnOpt);
+			const responseData: string[] = [];
+			const errorData: string[] = [];
+
+			proc.on("close", (code, signal) => {
+				if (code === 0) {
+					resolveOnce({
+						message: `${commandName} completed`,
+						data: responseData,
+					});
+					return;
+				}
+
+				const stderr = errorData.join("\n").trim();
+				const stdout = responseData.join("\n").trim();
+				const exitCodeText = code == null ? "unknown" : String(code);
+				const signalText = signal ? ` signal ${signal}` : "";
+				const base = `Running '${commandName}' failed with code ${exitCodeText}${signalText}`;
+				const details = [
+					stderr ? `stderr:\n${stderr}` : "",
+					!stderr && stdout ? `stdout:\n${stdout}` : "",
+				]
+					.filter(Boolean)
+					.join("\n");
+
+				rejectOnce(new InteropError(details ? `${base}\n${details}` : base));
+			});
+
+			proc.on("error", (err) => {
+				rejectOnce(err);
+			});
+
+			proc.stdout.on("error", (err) => {
+				rejectOnce(err);
+			});
+
+			proc.stdout.on("data", (data) => {
+				const lines = this.parseStream(data);
+				console.log(data.toString());
+				responseData.push(...lines);
+			});
+
+			proc.stderr?.on("error", (err) => {
+				rejectOnce(err);
+			});
+
+			proc.stderr?.on("data", (data) => {
+				const lines = this.parseStream(data);
+				console.error(data.toString());
+				errorData.push(...lines);
+			});
+		});
+	}
+
+	private parseStream(data: Buffer | string) {
+		const dataStr: string = data.toString();
+		const lines = dataStr.split("\n").filter((l) => l !== "");
+		return lines;
+	}
+}

package/src/interop/shell/shell.types.ts

@@ -0,0 +1,9 @@
+export type ShellResponse = {
+	message: string;
+	data: string[];
+};
+export interface ShellOptions {
+	cwd?: string;
+	/** Spawn env. Defaults to `process.env`. Not written to logs. */
+	env?: NodeJS.ProcessEnv;
+}

package/src/interop/types/detect-package-manager.ts

@@ -0,0 +1,45 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { Npm } from "../npm/npm.js";
+import { Pnpm } from "../pnpm/pnpm.js";
+import { Yarn } from "../yarn/yarn.js";
+import type { PackageManager } from "./package-manager.js";
+
+const LOCKFILES: Array<[string, () => PackageManager]> = [
+	["pnpm-lock.yaml", () => new Pnpm()],
+	["yarn.lock", () => new Yarn()],
+	["package-lock.json", () => new Npm()],
+];
+
+function fromLockfile(cwd: string): PackageManager | undefined {
+	for (const [file, factory] of LOCKFILES) {
+		if (existsSync(join(cwd, file))) return factory();
+	}
+	return undefined;
+}
+
+function fromUserAgent(): PackageManager | undefined {
+	const agent = process.env.npm_config_user_agent ?? "";
+	if (agent.startsWith("pnpm")) return new Pnpm();
+	if (agent.startsWith("yarn")) return new Yarn();
+	if (agent.startsWith("npm")) return new Npm();
+	return undefined;
+}
+
+export function detectPackageManager(cwd: string): PackageManager | undefined {
+	return fromLockfile(cwd) ?? fromUserAgent();
+}
+
+export function packageManagerFromString(name: string): PackageManager {
+	if (name === "yarn") return new Yarn();
+	if (name === "npm") return new Npm();
+	return new Pnpm();
+}
+
+export async function promptForPackageManager(): Promise<PackageManager> {
+	const rl = createInterface({ input: process.stdin, output: process.stdout });
+	const answer = await rl.question("Package manager? [pnpm/yarn/npm] (default: pnpm): ");
+	rl.close();
+	return packageManagerFromString(answer.trim().toLowerCase());
+}

package/src/interop/types/package-manager.ts

@@ -0,0 +1,7 @@
+import type { ShellResponse } from "../shell/shell.types.js";
+
+export interface PackageManager {
+	readonly name: "npm" | "pnpm" | "yarn";
+	install(options?: { cwd?: string }): Promise<ShellResponse>;
+	syncLockFile(options?: { cwd?: string }): Promise<ShellResponse>;
+}

package/src/interop/yarn/yarn.ts

@@ -0,0 +1,28 @@
+import { Shell } from "../shell/shell.js";
+import type { PackageManager } from "../types/package-manager.js";
+import type { YarnOptions } from "./yarn.types.js";
+
+const Commands = {
+	install: "install",
+};
+
+export class Yarn extends Shell implements PackageManager {
+	public readonly name = "yarn" as const;
+	protected program: string = "yarn";
+
+	public async install(options: YarnOptions = { cwd: "./" }) {
+		const { cwd } = options;
+		return this.run({ cwd }, Commands.install);
+	}
+
+	public async syncLockFile(options: YarnOptions = { cwd: "./" }) {
+		const { cwd } = options;
+		return this.run(
+			{ cwd },
+			Commands.install,
+			"--mode",
+			"update-lockfile",
+			"--ignore-scripts",
+		);
+	}
+}

package/{types/src/interop/yarn/yarn.types.d.ts → src/interop/yarn/yarn.types.ts}

@@ -1,3 +1,3 @@
 export type YarnOptions = {
-    cwd?: string;
+	cwd?: string;
 };

package/src/io/find-directories.ts

@@ -0,0 +1,13 @@
+import { glob } from "glob";
+import type { Directory } from "@decohere/core/io";
+
+export async function findDirectories(...pattern: string[]): Promise<Directory[]> {
+	const paths = await glob(pattern, { withFileTypes: true });
+	const dirs = paths
+		.filter((p) => p.isDirectory())
+		.map((p) => ({
+			name: p.name,
+			parentPath: p.parentPath,
+		}));
+	return dirs;
+}

package/src/io/find-file.ts

@@ -0,0 +1,37 @@
+import { glob } from "glob";
+import { FileEx } from "@decohere/core/io";
+
+export type FindFileOptions = {
+	cwd: string;
+	ignore?: string | string[];
+};
+
+export async function findFile(pattern: string) {
+	const files = await glob(pattern, { includeChildMatches: false });
+	if (files.length === 0) {
+		return;
+	}
+	const file = {
+		relativePath: files.at(0),
+	};
+	return file;
+}
+
+export async function findFiles(
+	patterns: string[],
+	options?: FindFileOptions,
+): Promise<FileEx[]> {
+	const paths = await glob(patterns, {
+		...options,
+		withFileTypes: true,
+	});
+	const files = paths
+		.filter((p) => p.isFile())
+		.map((p) => {
+			return new FileEx({
+				relativePath: p.relative(),
+				fullPath: p.fullpath(),
+			});
+		});
+	return files;
+}