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

package/src/cli.ts

@@ -1,442 +1,292 @@
 #!/usr/bin/env node
-
-import { Command, Option } from "@commander-js/extra-typings";
-import chalk from "chalk";
+import "./log.js"; // sets up DEBUG=true → DEBUG=* before anything else
+import { Command } from "@commander-js/extra-typings";
+import * as path from "path";
 import {
-  init,
-  clone,
-  sync,
-  root,
-  diff,
-  status,
-  log,
-  checkout,
-  commit,
-  url,
-  rm,
-  ls,
-  config,
-  watch,
-  read,
-} from "./commands.js";
+	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);
 
-import { createRequire } from "module";
-const require = createRequire(import.meta.url);
-const version = require("../package.json").version;
 const program = new Command()
-  .name("pushwork")
-  .description("Bidirectional directory synchronization using Automerge CRDTs")
-  .version(version, "-V, --version", "output the version number");
+	.name("pushwork")
+	.description("Bidirectional directory synchronization using Automerge CRDTs");
 
-// Init command
 program
-  .command("init")
-  .summary("Initialize sync in a directory")
-  .argument(
-    "[path]",
-    "Directory path to initialize (default: current directory)",
-    "."
-  )
-  .option(
-    "--sync-server <url>",
-    "Custom sync server URL"
-  )
-  .action(async (path, opts) => {
-    await init(path, { syncServer: opts.syncServer });
-  });
-
-// Track command (set root directory URL without full initialization)
-const trackAction = async (url: string, path: string, opts: { force: boolean }) => {
-  await root(url, path, { force: opts.force });
-};
+	.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("track")
-  .summary("Set root directory URL without full initialization")
-  .argument(
-    "<url>",
-    "AutomergeUrl of root directory (format: automerge:XXXXX)"
-  )
-  .argument(
-    "[path]",
-    "Directory path (default: current directory)",
-    "."
-  )
-  .option("-f, --force", "Overwrite existing pushwork setup", false)
-  .action(async (url, path, opts) => {
-    await trackAction(url, path, opts);
-  });
+	.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`);
+	});
 
-// Hidden alias for backwards compatibility
 program
-  .command("root", { hidden: true })
-  .argument("<url>")
-  .argument("[path]", "", ".")
-  .option("-f, --force", "", false)
-  .action(async (url: string, path: string, opts: { force: boolean }) => {
-    await trackAction(url, path, opts);
-  });
+	.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");
+	});
 
-// Clone command
 program
-  .command("clone")
-  .summary("Clone an existing synced directory")
-  .argument(
-    "<url>",
-    "AutomergeUrl of root directory to clone (format: automerge:XXXXX)"
-  )
-  .argument("<path>", "Target directory path")
-  .option("-f, --force", "Overwrite existing directory", false)
-  .option(
-    "--sync-server <url>",
-    "Custom sync server URL"
-  )
-  .option("-v, --verbose", "Verbose output", false)
-  .action(async (url, path, opts) => {
-    await clone(url, path, {
-      force: opts.force,
-      verbose: opts.verbose,
-      syncServer: opts.syncServer,
-    });
-  });
+	.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");
+	});
 
-// Commit command
 program
-  .command("commit")
-  .summary("Save local changes to Automerge documents")
-  .argument(
-    "[path]",
-    "Directory path to commit (default: current directory)",
-    "."
-  )
-  .action(async (path, _opts) => {
-    await commit(path);
-  });
+	.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");
+	});
 
-// Sync command
 program
-  .command("sync")
-  .summary("Run full bidirectional synchronization")
-  .argument(
-    "[path]",
-    "Directory path to sync (default: current directory)",
-    "."
-  )
-  .option(
-    "--dry-run",
-    "Show what would be done without applying changes",
-    false
-  )
-  .option(
-    "--gentle",
-    "Use config files and only sync changed files (instead of default full resync)",
-    false
-  )
-  .option(
-    "--nuclear",
-    "Recreate all Automerge documents from scratch",
-    false
-  )
-  .addOption(new Option("-f, --force", "Accepted for backwards compatibility").default(false).hideHelp())
-  .option("-v, --verbose", "Verbose output", false)
-  .action(async (path, opts) => {
-    await sync(path, {
-      dryRun: opts.dryRun,
-      force: opts.force,
-      gentle: opts.gentle,
-      nuclear: opts.nuclear,
-      verbose: opts.verbose,
-    });
-  });
+	.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");
+	});
 
-// Diff command
 program
-  .command("diff")
-  .summary("Show changes in working directory")
-  .argument(
-    "[path]",
-    "Limit diff to specific path (default: current directory)",
-    "."
-  )
-  .option("--name-only", "Show only changed file names", false)
-  .action(async (path, opts) => {
-    await diff(path, {
-      nameOnly: opts.nameOnly,
-    });
-  });
+	.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");
+		}
+	});
 
-// Status command
 program
-  .command("status")
-  .summary("Show sync status summary")
-  .argument("[path]", "Directory path (default: current directory)", ".")
-  .option(
-    "-v, --verbose",
-    "Show detailed status including document info and all tracked files",
-    false
-  )
-  .action(async (path, opts) => {
-    await status(path, {
-      verbose: opts.verbose,
-    });
-  });
+	.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`);
+	});
 
-// Log command
 program
-  .command("log")
-  .summary("Show sync history (experimental)")
-  .argument(
-    "[path]",
-    "Show history for specific file or directory (default: current directory)",
-    "."
-  )
-  .option("--oneline", "Compact one-line per sync format", false)
-  .option("--since <date>", "Show syncs since date")
-  .option("--limit <n>", "Limit number of syncs shown", "10")
-  .action(async (path, opts) => {
-    await log(path, {
-      oneline: opts.oneline,
-      since: opts.since,
-      limit: parseInt(opts.limit),
-    });
-  });
+	.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`);
+	});
 
-// Checkout command
 program
-  .command("checkout")
-  .summary("Restore to previous sync (experimental)")
-  .argument("<sync-id>", "Sync ID to restore to")
-  .argument(
-    "[path]",
-    "Specific path to restore (default: current directory)",
-    "."
-  )
-  .option(
-    "-f, --force",
-    "Force checkout even if there are uncommitted changes",
-    false
-  )
-  .action(async (syncId, path, opts) => {
-    await checkout(syncId, path, {
-      force: opts.force,
-    });
-  });
+	.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");
+	});
 
-// URL command
 program
-  .command("url")
-  .summary("Show the Automerge root URL")
-  .argument("[path]", "Directory path (default: current directory)", ".")
-  .action(async (path) => {
-    await url(path);
-  });
+	.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`);
+	});
 
-// Remove command
 program
-  .command("rm")
-  .summary("Remove local pushwork data")
-  .argument("[path]", "Directory path (default: current directory)", ".")
-  .action(async (path) => {
-    await rm(path);
-  });
+	.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`,
+		);
+	});
 
-// List command
 program
-  .command("ls")
-  .summary("List tracked files")
-  .argument("[path]", "Directory path (default: current directory)", ".")
-  .option("-v, --verbose", "Show with Automerge URLs", false)
-  .action(async (path, opts) => {
-    await ls(path, {
-      verbose: opts.verbose,
-    });
-  });
+	.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`,
+			);
+		}
+	});
 
-// Config command
 program
-  .command("config")
-  .summary("View or edit configuration")
-  .argument("[path]", "Directory path (default: current directory)", ".")
-  .option("--list", "Show full configuration", false)
-  .option(
-    "--get <key>",
-    "Get specific config value (dot notation, e.g., sync.move_detection_threshold)"
-  )
-  .action(async (path, opts) => {
-    await config(path, {
-      list: opts.list,
-      get: opts.get,
-    });
-  });
-
-// Watch command
-program
-  .command("watch")
-  .summary("Watch directory for changes, build, and sync")
-  .argument(
-    "[path]",
-    "Directory path to sync (default: current directory)",
-    "."
-  )
-  .option(
-    "--script <command>",
-    "Build script to run before syncing",
-    "pnpm build"
-  )
-  .option(
-    "--dir <dir>",
-    "Directory to watch for changes (relative to working directory)",
-    "src"
-  )
-  .option("-v, --verbose", "Show build script output", false)
-  .action(async (path, opts) => {
-    await watch(path, {
-      script: opts.script,
-      watchDir: opts.dir,
-      verbose: opts.verbose,
-    });
-  });
-
-// Read command
-program
-  .command("read")
-  .summary("Read a file document by its Automerge URL")
-  .argument(
-    "<url>",
-    "AutomergeUrl of file document (format: automerge:XXXXX)"
-  )
-  .option("-r, --remote", "Read from sync server instead of local storage", false)
-  .action(async (url, opts) => {
-    await read(url, {
-      remote: opts.remote,
-    });
-  });
-
-// Completion command (hidden from help)
-program.command("completion", { hidden: true }).action(() => {
-  // Generate completion dynamically from registered commands
-  const commands = program.commands
-    .filter((cmd) => cmd.name() !== "completion") // Exclude self
-    .map((cmd) => {
-      const name = cmd.name();
-      const desc = (cmd.summary() || cmd.description() || "").replace(
-        /'/g,
-        "\\'"
-      );
-      return `'${name}:${desc}'`;
-    })
-    .join(" ");
-
-  // Generate option completions for each command
-  const commandCases = program.commands
-    .filter((cmd) => cmd.name() !== "completion")
-    .map((cmd) => {
-      const options = cmd.options
-        .filter((opt) => opt.flags !== "-h, --help") // Exclude help
-        .map((opt) => {
-          // Parse flags like "-v, --verbose" or "--dry-run"
-          const flags = opt.flags.split(",").map((f) => f.trim());
-          const desc = (opt.description || "")
-            .replace(/'/g, "\\'")
-            .replace(/\n/g, " ");
-
-          // For options with arguments like "--sync-server <url>"
-          // Extract just the flag part
-          const cleanFlags = flags.map((f) => f.split(/\s+/)[0]);
+	.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`);
+		}
+	});
 
-          if (cleanFlags.length > 1) {
-            // Multiple flags (short and long): '(-v --verbose)'{-v,--verbose}'[description]'
-            const short = cleanFlags[0];
-            const long = cleanFlags[1];
-            return `'(${short} ${long})'{${short},${long}}'[${desc}]'`;
-          } else {
-            // Single flag: '--flag[description]'
-            return `'${cleanFlags[0]}[${desc}]'`;
-          }
-        })
-        .join(" \\\n        ");
-
-      return options
-        ? `    ${cmd.name()})
-      _arguments \\
-        ${options}
-      ;;`
-        : "";
-    })
-    .filter(Boolean)
-    .join("\n");
-
-  const completionScript = `
-# pushwork completion for zsh
-_pushwork() {
-  local -a commands
-  commands=(${commands})
-  
-  _arguments -C \\
-    '1: :->command' \\
-    '*::arg:->args'
-  
-  case $state in
-    command)
-      _describe 'command' commands
-      ;;
-    args)
-      case $words[1] in
-${commandCases}
-      esac
-      ;;
-  esac
-}
-
-compdef _pushwork pushwork
-    `.trim();
-
-  console.log(completionScript);
-});
-
-process.on("unhandledRejection", (error) => {
-  console.log(chalk.bgRed.white(" ERROR "));
-  if (error instanceof Error && error.stack) {
-    console.log(chalk.red(error.stack));
-  } else {
-    console.error(chalk.red(error));
-  }
-  process.exit(1);
-});
-
-// Configure help colors using Commander v13's built-in color support
 program
-  .configureHelp({
-    styleTitle: (str) => chalk.bold(str),
-    styleCommandText: (str) => chalk.white(str),
-    styleCommandDescription: (str) => chalk.dim(str),
-    styleOptionText: (str) => chalk.green(str),
-    styleArgumentText: (str) => chalk.cyan(str),
-    subcommandTerm: (cmd) => {
-      const opts = cmd.options
-        .filter((opt) => opt.flags !== "-h, --help")
-        .map((opt) => opt.short || opt.long)
-        .join(", ");
-
-      const name = chalk.white(cmd.name());
-      const args = cmd.registeredArguments
-        .map((arg) =>
-          arg.required
-            ? chalk.cyan(`<${arg.name()}>`)
-            : chalk.dim(`[${arg.name()}]`)
-        )
-        .join(" ");
-
-      return [name, args, opts && chalk.dim(`[${opts}]`)]
-        .filter(Boolean)
-        .join(" ");
-    },
-  })
-  .addHelpText(
-    "after",
-    chalk.dim(
-      '\nEnable tab completion by adding this to your ~/.zshrc:\neval "$(pushwork completion)"'
-    )
-  );
-
-program.parseAsync();
+	.parseAsync(process.argv)
+	.then(() => process.exit(0))
+	.catch((err) => {
+		process.stderr.write(
+			`pushwork: ${err instanceof Error ? err.message : String(err)}\n`,
+		);
+		process.exit(1);
+	});