pushwork 2.0.0-a.sub.0 → 2.0.0-preview

package/src/config.ts

@@ -0,0 +1,64 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import type { AutomergeUrl } from "@automerge/automerge-repo";
+
+export type Backend = "legacy" | "subduction";
+
+export const CONFIG_VERSION = 3;
+
+export interface PushworkConfig {
+	version: typeof CONFIG_VERSION;
+	rootUrl: AutomergeUrl;
+	backend: Backend;
+	shape: string;
+	artifactDirectories: string[];
+	branches: boolean;
+}
+
+const DIR = ".pushwork";
+const CONFIG = "config.json";
+const STORAGE = "storage";
+
+export const pushworkDir = (root: string) => path.join(root, DIR);
+export const storageDir = (root: string) => path.join(root, DIR, STORAGE);
+
+export async function readConfig(root: string): Promise<PushworkConfig> {
+	const text = await fs.readFile(path.join(root, DIR, CONFIG), "utf8");
+	const parsed = JSON.parse(text) as Partial<PushworkConfig>;
+	if (parsed.version !== CONFIG_VERSION) {
+		throw new Error(
+			`pushwork config version mismatch: expected ${CONFIG_VERSION}, got ${parsed.version ?? "(missing)"}`,
+		);
+	}
+	if (!parsed.rootUrl) throw new Error("pushwork config missing rootUrl");
+	if (!parsed.backend) throw new Error("pushwork config missing backend");
+	if (!parsed.shape) throw new Error("pushwork config missing shape");
+	return {
+		version: CONFIG_VERSION,
+		rootUrl: parsed.rootUrl,
+		backend: parsed.backend,
+		shape: parsed.shape,
+		artifactDirectories: parsed.artifactDirectories ?? [],
+		branches: parsed.branches ?? true,
+	};
+}
+
+export async function writeConfig(
+	root: string,
+	config: PushworkConfig,
+): Promise<void> {
+	await fs.mkdir(path.join(root, DIR), { recursive: true });
+	await fs.writeFile(
+		path.join(root, DIR, CONFIG),
+		JSON.stringify(config, null, 2) + "\n",
+	);
+}
+
+export async function configExists(root: string): Promise<boolean> {
+	try {
+		await fs.access(path.join(root, DIR, CONFIG));
+		return true;
+	} catch {
+		return false;
+	}
+}

package/src/fs-tree.ts

@@ -0,0 +1,70 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import type { Ignore } from "ignore";
+import { isIgnored } from "./ignore.js";
+import { log } from "./log.js";
+
+const dlog = log("fs-tree");
+
+export type FileTree = Map<string, Uint8Array>;
+
+const toPosix = (p: string) => p.split(path.sep).join("/");
+
+export async function walkDir(root: string, ig: Ignore): Promise<FileTree> {
+	dlog("walkDir root=%s", root);
+	const tree: FileTree = new Map();
+	await walk(root, root, ig, tree);
+	dlog("walkDir done: %d files", tree.size);
+	return tree;
+}
+
+async function walk(
+	root: string,
+	current: string,
+	ig: Ignore,
+	tree: FileTree,
+): Promise<void> {
+	let names: string[];
+	try {
+		names = await fs.readdir(current);
+	} catch {
+		return;
+	}
+	for (const name of names) {
+		const full = path.join(current, name);
+		const rel = toPosix(path.relative(root, full));
+		if (isIgnored(ig, rel)) {
+			dlog("skip ignored: %s", rel);
+			continue;
+		}
+		let stat;
+		try {
+			stat = await fs.lstat(full);
+		} catch {
+			continue;
+		}
+		if (stat.isSymbolicLink()) continue;
+		if (stat.isDirectory()) {
+			await walk(root, full, ig, tree);
+		} else if (stat.isFile()) {
+			const bytes = await fs.readFile(full);
+			tree.set(rel, new Uint8Array(bytes));
+		}
+	}
+}
+
+export function byteEq(a: Uint8Array | undefined, b: Uint8Array): boolean {
+	if (!a) return false;
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+
+export async function writeFileAtomic(
+	target: string,
+	bytes: Uint8Array,
+): Promise<void> {
+	await fs.mkdir(path.dirname(target), { recursive: true });
+	await fs.writeFile(target, bytes);
+}
+

package/src/ignore.ts

@@ -0,0 +1,33 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import ignore, { type Ignore } from "ignore";
+import { log } from "./log.js";
+
+const dlog = log("ignore");
+
+export const ALWAYS_IGNORE = [".pushwork", ".git", "node_modules"];
+export const IGNORE_FILE = ".pushworkignore";
+
+export async function loadIgnore(root: string): Promise<Ignore> {
+	const ig = ignore().add(ALWAYS_IGNORE);
+	dlog("always-ignored: %o", ALWAYS_IGNORE);
+	try {
+		const text = await fs.readFile(path.join(root, IGNORE_FILE), "utf8");
+		const patterns = text
+			.split(/\r?\n/)
+			.map((l) => l.trim())
+			.filter((l) => l && !l.startsWith("#"));
+		ig.add(patterns);
+		dlog("loaded %d patterns from %s", patterns.length, IGNORE_FILE);
+	} catch (err) {
+		const e = err as NodeJS.ErrnoException;
+		if (e.code !== "ENOENT") throw err;
+		dlog("no %s in %s", IGNORE_FILE, root);
+	}
+	return ig;
+}
+
+export function isIgnored(ig: Ignore, relativePath: string): boolean {
+	if (relativePath === "" || relativePath === ".") return false;
+	return ig.ignores(relativePath);
+}

package/src/index.ts

@@ -1,4 +1,38 @@
-export * from "./core/index.js";
-export * from "./utils/index.js";
-export * from "./types/index.js";
-export * from "./cli.js";
+export {
+	init,
+	clone,
+	sync,
+	save,
+	status,
+	diff,
+	url,
+	currentBranch,
+	createBranch,
+	switchBranch,
+	listBranches,
+	mergeBranch,
+	previewMerge,
+	cutWorkdir,
+	pasteStash,
+	showStashes,
+} from "./pushwork.js";
+export type { MergeReport, MergePreview, MergePreviewEntry } from "./pushwork.js";
+export type { Stash, StashEntry } from "./stash.js";
+export type { Backend, PushworkConfig } from "./config.js";
+export { CONFIG_VERSION } from "./config.js";
+export type { Shape, VfsNode, UnixFileEntry } from "./shapes/index.js";
+export {
+	vfsShape,
+	patchworkFolderShape,
+	isInArtifactDir,
+	normalizeArtifactDir,
+	pinUrl,
+	stripHeads,
+} from "./shapes/index.js";
+export {
+	DEFAULT_BRANCH,
+	detectDocType,
+	isBranchesDoc,
+	resolveEffectiveRoot,
+	type BranchesDoc,
+} from "./branches.js";

package/src/log.ts

@@ -0,0 +1,8 @@
+import debug from "debug";
+
+if (process.env.DEBUG === "true") {
+	process.env.DEBUG = "*";
+	debug.enable("*");
+}
+
+export const log = (ns: string) => debug(`pushwork:${ns}`);