pushwork 2.0.0-preview → 2.0.0-preview.3

package/src/branches.ts

@@ -1,93 +0,0 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-import {
-	type AutomergeUrl,
-	type DocHandle,
-	type Repo,
-} from "@automerge/automerge-repo";
-import { log } from "./log.js";
-
-const dlog = log("branches");
-
-export const META = "@patchwork";
-export const DEFAULT_BRANCH = "default";
-
-export type BranchesDoc = {
-	"@patchwork": { type: "branches" };
-	branches: { [name: string]: AutomergeUrl };
-};
-
-export const isBranchesDoc = (doc: unknown): doc is BranchesDoc => {
-	if (!doc || typeof doc !== "object") return false;
-	const meta = (doc as Record<string, unknown>)[META];
-	return (
-		!!meta &&
-		typeof meta === "object" &&
-		(meta as Record<string, unknown>).type === "branches"
-	);
-};
-
-export function detectDocType(
-	doc: unknown,
-): "branches" | "folder" | "directory" | "unknown" {
-	if (!doc || typeof doc !== "object") return "unknown";
-	const meta = (doc as Record<string, unknown>)[META];
-	if (!meta || typeof meta !== "object") return "unknown";
-	const t = (meta as Record<string, unknown>).type;
-	if (t === "branches" || t === "folder" || t === "directory") return t;
-	return "unknown";
-}
-
-export async function resolveEffectiveRoot(
-	repo: Repo,
-	rootHandle: DocHandle<unknown>,
-	branchName: string | null,
-): Promise<DocHandle<unknown>> {
-	const doc = rootHandle.doc();
-	if (!isBranchesDoc(doc)) return rootHandle;
-	if (!branchName) {
-		throw new Error(
-			"pushwork repo uses branches but no branch name is set",
-		);
-	}
-	const url = doc.branches?.[branchName];
-	if (!url) {
-		throw new Error(
-			`branch "${branchName}" not found in branches doc ${rootHandle.url}`,
-		);
-	}
-	dlog("resolveEffectiveRoot branch=%s → %s", branchName, url);
-	return repo.find<unknown>(url);
-}
-
-export function listBranchNames(branchesDoc: BranchesDoc): string[] {
-	return Object.keys(branchesDoc.branches ?? {}).sort();
-}
-
-const BRANCH_FILE = path.join(".pushwork", "branch");
-
-export async function readBranchFile(root: string): Promise<string | null> {
-	try {
-		const text = await fs.readFile(path.join(root, BRANCH_FILE), "utf8");
-		return text.trim() || null;
-	} catch (err) {
-		if ((err as NodeJS.ErrnoException).code === "ENOENT") return null;
-		throw err;
-	}
-}
-
-export async function writeBranchFile(
-	root: string,
-	branchName: string,
-): Promise<void> {
-	await fs.mkdir(path.join(root, ".pushwork"), { recursive: true });
-	await fs.writeFile(path.join(root, BRANCH_FILE), branchName + "\n");
-}
-
-export async function deleteBranchFile(root: string): Promise<void> {
-	try {
-		await fs.unlink(path.join(root, BRANCH_FILE));
-	} catch (err) {
-		if ((err as NodeJS.ErrnoException).code !== "ENOENT") throw err;
-	}
-}

package/src/cli.ts

@@ -1,292 +0,0 @@
-#!/usr/bin/env node
-import "./log.js"; // sets up DEBUG=true → DEBUG=* before anything else
-import { Command } from "@commander-js/extra-typings";
-import * as path from "path";
-import {
-	clone,
-	createBranch,
-	currentBranch,
-	cutWorkdir,
-	diff,
-	init,
-	listBranches,
-	mergeBranch,
-	pasteStash,
-	previewMerge,
-	save,
-	showStashes,
-	status,
-	switchBranch,
-	sync,
-	url,
-} from "./pushwork.js";
-import { log } from "./log.js";
-
-const dlog = log("cli");
-
-const collect = (value: string, prev: string[] | undefined) =>
-	(prev ?? []).concat(value);
-
-const program = new Command()
-	.name("pushwork")
-	.description("Bidirectional directory synchronization using Automerge CRDTs");
-
-program
-	.command("init")
-	.description("Initialize pushwork in a directory")
-	.argument("[dir]", "Directory to initialize", ".")
-	.option("--sub", "Use subduction backend")
-	.option(
-		"--shape <shape>",
-		"Document shape: vfs, patchwork-folder, or path to a custom shape module",
-		"vfs",
-	)
-	.option(
-		"--artifact-dir <dir>",
-		"Directory whose contents are stored as ImmutableString and pinned with heads in the root doc. Repeatable.",
-		collect,
-		undefined as string[] | undefined,
-	)
-	.option("--no-branches", "Skip wrapping the root doc in a branches doc")
-	.action(async (dir, opts) => {
-		dlog("init dir=%s opts=%o", dir, opts);
-		const u = await init({
-			dir: path.resolve(dir),
-			backend: opts.sub ? "subduction" : "legacy",
-			shape: opts.shape,
-			artifactDirectories: opts.artifactDir,
-			branches: opts.branches,
-		});
-		process.stderr.write(`initialized ${u}\n`);
-	});
-
-program
-	.command("clone")
-	.description("Clone an automerge URL into a directory")
-	.argument("<url>", "automerge: URL")
-	.argument("[dir]", "Target directory", ".")
-	.option("--sub", "Use subduction backend")
-	.option(
-		"--shape <shape>",
-		"Document shape: vfs, patchwork-folder, or path to a custom shape module",
-		"vfs",
-	)
-	.option(
-		"--artifact-dir <dir>",
-		"Directory whose contents are stored as ImmutableString and pinned with heads in the root doc. Repeatable.",
-		collect,
-		undefined as string[] | undefined,
-	)
-	.option("--branch <name>", "Branch to track when cloning a branches doc")
-	.action(async (u, dir, opts) => {
-		dlog("clone url=%s dir=%s opts=%o", u, dir, opts);
-		await clone({
-			url: u,
-			dir: path.resolve(dir),
-			backend: opts.sub ? "subduction" : "legacy",
-			shape: opts.shape,
-			artifactDirectories: opts.artifactDir,
-			branch: opts.branch,
-		});
-		process.stderr.write(`cloned into ${path.resolve(dir)}\n`);
-	});
-
-program
-	.command("url")
-	.description("Print the automerge URL of this pushwork repo")
-	.action(async () => {
-		dlog("url cwd=%s", process.cwd());
-		const u = await url(process.cwd());
-		process.stdout.write(u + "\n");
-	});
-
-program
-	.command("sync")
-	.description("Sync local changes with peers")
-	.action(async () => {
-		dlog("sync cwd=%s", process.cwd());
-		await sync(process.cwd());
-		process.stderr.write("synced\n");
-	});
-
-program
-	.command("save")
-	.alias("commit")
-	.description("Commit local changes to the current branch without contacting the sync server")
-	.action(async () => {
-		dlog("save cwd=%s", process.cwd());
-		await save(process.cwd());
-		process.stderr.write("saved\n");
-	});
-
-program
-	.command("status")
-	.description("Show current branch and changes against it")
-	.action(async () => {
-		const { branch, diff: d } = await status(process.cwd());
-		const lines: string[] = [];
-		if (branch) lines.push(`On branch ${branch}`);
-		else lines.push("(no branches)");
-		const total = d.added.length + d.modified.length + d.deleted.length;
-		if (total === 0) {
-			lines.push("nothing to save, working tree clean");
-		} else {
-			lines.push("Changes:");
-			for (const p of d.modified) lines.push(`  modified:   ${p}`);
-			for (const p of d.added) lines.push(`  added:      ${p}`);
-			for (const p of d.deleted) lines.push(`  deleted:    ${p}`);
-		}
-		process.stdout.write(lines.join("\n") + "\n");
-	});
-
-program
-	.command("diff")
-	.description("Show textual diffs of local changes against the current branch")
-	.argument("[path]", "Limit to a specific path")
-	.action(async (limitPath) => {
-		const entries = await diff(process.cwd(), limitPath);
-		if (entries.length === 0) {
-			process.stdout.write("(no changes)\n");
-			return;
-		}
-		const { createPatch } = await import("diff");
-		const td = new TextDecoder("utf-8", { fatal: false });
-		for (const e of entries) {
-			const before = e.before ? td.decode(e.before) : "";
-			const after = e.after ? td.decode(e.after) : "";
-			const header =
-				e.kind === "added" ? `+++ ${e.path}` :
-				e.kind === "deleted" ? `--- ${e.path}` :
-				`*** ${e.path}`;
-			process.stdout.write(header + "\n");
-			process.stdout.write(createPatch(e.path, before, after, "", "") + "\n");
-		}
-	});
-
-program
-	.command("branch")
-	.description("With no arg: print the current branch. With <name>: create a new branch from the current one (offline).")
-	.argument("[name]", "Name of the new branch")
-	.action(async (name) => {
-		if (!name) {
-			const cur = await currentBranch(process.cwd());
-			process.stdout.write((cur ?? "(none)") + "\n");
-			return;
-		}
-		const newUrl = await createBranch(process.cwd(), name);
-		process.stderr.write(`created branch ${name} → ${newUrl}\n`);
-	});
-
-program
-	.command("switch")
-	.description("Switch to a branch (offline). With no name: list branches.")
-	.argument("[name]", "Name of the branch to switch to")
-	.action(async (name) => {
-		if (!name) {
-			const { current, names } = await listBranches(process.cwd());
-			for (const n of names) {
-				process.stdout.write(`${n === current ? "* " : "  "}${n}\n`);
-			}
-			return;
-		}
-		await switchBranch(process.cwd(), name);
-		process.stderr.write(`switched to ${name}\n`);
-	});
-
-program
-	.command("merge")
-	.description("Apply changes from <source> branch onto the current branch (offline)")
-	.argument("<source>", "Branch to merge into the current one")
-	.option("--dry", "Preview the merge without applying")
-	.action(async (source, opts) => {
-		if (opts.dry) {
-			const preview = await previewMerge(process.cwd(), source);
-			const lines: string[] = [];
-			lines.push(`Merging ${preview.source} into ${preview.target} (preview)`);
-			if (preview.entries.length === 0) {
-				lines.push("(no changes)");
-				process.stdout.write(lines.join("\n") + "\n");
-				return;
-			}
-			const { createPatch } = await import("diff");
-			const td = new TextDecoder("utf-8", { fatal: false });
-			for (const e of preview.entries) {
-				const before = e.before ? td.decode(e.before) : "";
-				const after = td.decode(e.after);
-				const tag = e.kind === "added" ? "added" : "merged";
-				lines.push(`  ${tag}:     ${e.path}`);
-				lines.push(createPatch(e.path, before, after, "", ""));
-			}
-			process.stdout.write(lines.join("\n") + "\n");
-			return;
-		}
-		const report = await mergeBranch(process.cwd(), source);
-		const lines: string[] = [];
-		lines.push(`Merging ${report.source} into ${report.target}`);
-		if (report.merged.length === 0 && report.added.length === 0) {
-			lines.push("(no changes)");
-		} else {
-			for (const p of report.merged) lines.push(`  merged:     ${p}`);
-			for (const p of report.added) lines.push(`  added:      ${p}`);
-		}
-		process.stdout.write(lines.join("\n") + "\n");
-	});
-
-program
-	.command("cut")
-	.description("Stash working-tree changes against the current branch and reset the tree to clean (offline)")
-	.argument("[name]", "Optional name for the stash entry")
-	.action(async (name) => {
-		const result = await cutWorkdir(process.cwd(), { name });
-		process.stderr.write(`cut #${result.id}: ${result.entries} entr${result.entries === 1 ? "y" : "ies"}\n`);
-	});
-
-program
-	.command("paste")
-	.description("Re-apply a stashed set of changes; default is the most recent (offline)")
-	.argument("[id-or-name]", "Stash id or name")
-	.action(async (selector) => {
-		const result = await pasteStash(process.cwd(), selector);
-		process.stderr.write(
-			`pasted #${result.id}${result.name ? ` (${result.name})` : ""}: ${result.entries} entr${result.entries === 1 ? "y" : "ies"}\n`,
-		);
-	});
-
-program
-	.command("cuts")
-	.description("List stashed change sets (newest first)")
-	.action(async () => {
-		const stashes = await showStashes(process.cwd());
-		if (stashes.length === 0) {
-			process.stdout.write("(no stashes)\n");
-			return;
-		}
-		for (const s of stashes) {
-			const ts = new Date(s.createdAt).toISOString();
-			const label = s.name ? `"${s.name}"` : "";
-			const branch = s.branch ? ` on ${s.branch}` : "";
-			process.stdout.write(
-				`#${s.id}${label ? " " + label : ""}${branch}  ${s.entries.length} entr${s.entries.length === 1 ? "y" : "ies"}  ${ts}\n`,
-			);
-		}
-	});
-
-program
-	.command("branches")
-	.description("List branches")
-	.action(async () => {
-		const { current, names } = await listBranches(process.cwd());
-		for (const n of names) {
-			process.stdout.write(`${n === current ? "* " : "  "}${n}\n`);
-		}
-	});
-
-program
-	.parseAsync(process.argv)
-	.then(() => process.exit(0))
-	.catch((err) => {
-		process.stderr.write(
-			`pushwork: ${err instanceof Error ? err.message : String(err)}\n`,
-		);
-		process.exit(1);
-	});

package/src/config.ts

@@ -1,64 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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,38 +0,0 @@
-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

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