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

package/ARCHITECTURE-ACCORDING-TO-CLAUDE.md

@@ -1,248 +0,0 @@
-# Pushwork Architecture
-
-> This document was generated by Claude from reading the source code.
-
-Pushwork is a CLI tool for bidirectional file synchronization using **Automerge CRDTs**. It maps a local filesystem directory tree to a mirror tree of Automerge documents and syncs them through a WebSocket relay server. Multiple peers can edit the same files and changes merge automatically.
-
-## Module Diagram
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│                        CLI (cli.ts)                         │
-│              Commander.js argument parsing                   │
-└────────────────────────┬────────────────────────────────────┘
-                         │
-                         ▼
-┌─────────────────────────────────────────────────────────────┐
-│                    Commands (commands.ts)                     │
-│  setupCommandContext() → creates Repo + SyncEngine           │
-│  sync(), commit(), status(), diff(), clone(), init(), ...    │
-└────────────────────────┬────────────────────────────────────┘
-                         │
-          ┌──────────────┼──────────────┐
-          ▼              ▼              ▼
-┌──────────────┐ ┌──────────────┐ ┌──────────────────────┐
-│  ConfigMgr   │ │  RepoFactory │ │      SyncEngine      │
-│ (config.ts)  │ │(repo-factory)│ │  (sync-engine.ts)    │
-│              │ │              │ │                      │
-│ defaults <   │ │ Automerge    │ │  Orchestrates the    │
-│ global <     │ │ Repo with    │ │  entire sync cycle   │
-│ local        │ │ storage +    │ │                      │
-└──────────────┘ │ WebSocket    │ │  ┌────────────────┐  │
-                 └──────────────┘ │  │ChangeDetector  │  │
-                                  │  │ FS vs snapshot  │  │
-                                  │  │ vs remote docs  │  │
-                                  │  └────────────────┘  │
-                                  │  ┌────────────────┐  │
-                                  │  │ MoveDetector   │  │
-                                  │  │ content-sim    │  │
-                                  │  │ rename detect  │  │
-                                  │  └────────────────┘  │
-                                  │  ┌────────────────┐  │
-                                  │  │SnapshotManager │  │
-                                  │  │ .pushwork/     │  │
-                                  │  │ snapshot.json  │  │
-                                  │  └────────────────┘  │
-                                  └──────────┬───────────┘
-                                             │
-                    ┌────────────────────────┼────────────────────┐
-                    ▼                        ▼                    ▼
-          ┌─────────────────┐   ┌──────────────────┐   ┌─────────────────┐
-          │   text-diff.ts  │   │ network-sync.ts  │   │  directory.ts   │
-          │                 │   │                  │   │                 │
-          │ spliceText()    │   │ waitForSync()    │   │ getPlainUrl()   │
-          │ updateText      │   │ waitForBidi      │   │ getVersioned    │
-          │ Content()       │   │ directionalSync()│   │ Url()           │
-          │ readDocContent()│   │ batch size: 10   │   │ findFileIn      │
-          └─────────────────┘   └────────┬─────────┘   │ Directory()     │
-                                         │             └─────────────────┘
-                                         ▼
-                              ┌──────────────────────┐
-                              │   Automerge Relay     │
-                              │  (WebSocket server)   │
-                              │  sync3.automerge.org  │
-                              └──────────────────────┘
-```
-
-## Source Layout
-
-```
-src/
-  cli.ts                  — Commander.js entry point; registers all commands
-  commands.ts             — Command implementations; shared setupCommandContext()
-  index.ts                — Library export entry point
-
-  core/
-    sync-engine.ts        — Two-phase sync coordinator (the heart of the system)
-    change-detection.ts   — ChangeDetector: local + remote diff engine
-    move-detection.ts     — MoveDetector: content-similarity-based rename detection
-    snapshot.ts           — SnapshotManager: reads/writes .pushwork/snapshot.json
-    config.ts             — ConfigManager: loads/merges defaults < global < local
-
-  utils/
-    repo-factory.ts       — Creates the Automerge Repo with storage + network adapters
-    network-sync.ts       — waitForSync(), waitForBidirectionalSync()
-    text-diff.ts          — spliceText(), updateTextContent(), readDocContent()
-    content.ts            — contentHash(), isContentEqual()
-    directory.ts          — getPlainUrl(), findFileInDirectoryHierarchy()
-    fs.ts                 — readFileContent(), writeFileContent(), listDirectory()
-    mime-types.ts         — isEnhancedTextFile(), getEnhancedMimeType()
-    string-similarity.ts  — Sørensen-Dice coefficient for move detection
-    output.ts             — Output singleton (ora spinner + chalk colors)
-    trace.ts              — Debug tracing helpers
-
-  types/
-    documents.ts          — FileDocument, DirectoryDocument, DirectoryEntry
-    snapshot.ts           — SyncSnapshot, SnapshotFileEntry, SyncResult
-    config.ts             — DirectoryConfig, GlobalConfig, CLI option interfaces
-```
-
-## Data Model
-
-Every node in the synced tree is an Automerge document:
-
-- **FileDocument** — A file. Content is either collaborative text (mutable CRDT string supporting character-level `splice`) or raw bytes (for binary files). Also stores name, extension, mimeType, and permissions metadata.
-- **DirectoryDocument** — A directory. Contains a `docs` array of `{name, type, url}` entries pointing to child documents. Forms a tree rooted at one directory document.
-- **DirectoryEntry** — A single `{name, type, url}` reference inside a directory's `docs` array. For artifact files, the URL includes Automerge heads (a versioned snapshot); for regular files, it's a plain mutable URL.
-
-```
-DirectoryDocument (root)
-├── docs: [
-│   { name: "readme.md",   type: "file",   url: "automerge:abc123" }
-│   { name: "src",          type: "folder", url: "automerge:def456" }
-│   { name: "config.json",  type: "file",   url: "automerge:ghi789" }
-│ ]
-│
-└── DirectoryDocument (src/)
-    └── docs: [
-        { name: "index.ts", type: "file", url: "automerge:jkl012" }
-      ]
-```
-
-## How the Layers Connect
-
-### CLI → Commands
-
-`cli.ts` registers Commander.js commands and calls exported functions from `commands.ts`. The CLI layer is thin — it only handles argument parsing, option validation, and process exits. It doesn't touch Automerge directly.
-
-### Commands → Core
-
-`commands.ts` provides the shared setup function `setupCommandContext()`, which:
-
-1. Verifies the `.pushwork/` directory exists
-2. Loads and merges config (defaults < global `~/.pushwork/config.json` < local `.pushwork/config.json`)
-3. Creates an Automerge `Repo` via `createRepo()` — sets up `NodeFSStorageAdapter` for local persistence and optionally a `BrowserWebSocketClientAdapter` for network sync
-4. Instantiates a `SyncEngine` with the repo, working directory, and config
-
-Every command (sync, commit, status, diff, ls, etc.) calls `setupCommandContext()`, uses the `SyncEngine`, then calls `safeRepoShutdown()`.
-
-### SyncEngine — The Coordinator
-
-`SyncEngine` owns the entire sync cycle and holds references to three subsystems:
-
-- **ChangeDetector** — compares local filesystem state against the snapshot and remote Automerge documents to classify every file as local-only, remote-only, both-changed, or unchanged
-- **MoveDetector** — pairs local-only deletions with local-only creations using content similarity (Sørensen-Dice coefficient) to detect renames
-- **SnapshotManager** — reads and writes `.pushwork/snapshot.json`, which records the last-known state of every tracked file and directory
-
-## The Sync Cycle
-
-When you run `pushwork sync`, the following happens:
-
-```
-1. NETWORK WAIT
-   Wait for any incoming remote changes to arrive
-   (bidirectional sync poll until heads stabilize)
-         │
-         ▼
-2. DETECT CHANGES + MOVES
-   Compare local filesystem, snapshot heads, and
-   remote document heads to classify every file.
-   Pair deletions with creations to detect renames.
-         │
-         ▼
-3. PUSH (local → remote)
-   Process directories deepest-first:
-     new files    → repo.create() a new Automerge doc
-     modified     → handle.changeAt(heads) + spliceText()
-     deleted      → remove entry from parent directory doc
-     moved        → rename entry in parent directory doc
-         │
-         ▼
-4. NETWORK UPLOAD
-   waitForSync() — push docs to relay in batches of 10
-   waitForBidirectionalSync() — poll until heads stabilize
-         │
-         ▼
-5. RE-DETECT CHANGES
-   Fresh change detection pass; filter to remote-only
-   and both-changed files
-         │
-         ▼
-6. PULL (remote → local)
-   Write remote changes to the local filesystem
-   Process shallowest paths first (parents before children)
-         │
-         ▼
-7. UPDATE SNAPSHOT
-   Re-read all document heads, save snapshot.json
-```
-
-### The Snapshot as 3-Way Baseline
-
-The snapshot's `head` (Automerge document heads) for each file acts as the common ancestor in a 3-way comparison:
-
-- **Local filesystem content** vs **content at snapshot head** = local changes
-- **Current Automerge document** vs **snapshot head** = remote changes
-- Both changed → `BOTH_CHANGED` (the CRDT handles merge automatically via `changeAt`)
-
-## Key Design Decisions
-
-### Leaf-First Push Ordering
-
-During the push phase, directories are sorted deepest-first. This guarantees that when a parent directory document is updated, all its children's Automerge documents are already finalized with their correct URLs. The parent then records the correct versioned URLs.
-
-### `changeAt(heads)` for Merging
-
-Edits branch from the snapshot's known heads using `handle.changeAt(heads, callback)`. This gives Automerge a proper common ancestor for conflict-free 3-way merge. Without this, concurrent edits from different peers would overwrite each other instead of merging.
-
-### Orphaned Deletions
-
-Deleting a file just removes it from its parent directory's `docs` array. The Automerge document itself is left as an orphan — clearing a large text CRDT would be O(n) in character operations, which is very slow for large files.
-
-### Artifact Directories
-
-Files in configured `artifact_directories` (default: `dist/`) are treated as immutable snapshots rather than collaboratively-edited text. They use `RawString` (not the text CRDT), are never diffed/spliced, and are always replaced with a new document on update. A SHA-256 `contentHash` in the snapshot detects local changes without reading the Automerge doc.
-
-### Batched Network Sync
-
-Documents sync to the relay server in batches of 10 (`SYNC_BATCH_SIZE`). The Automerge sync server is single-threaded with no backpressure, so sending 100+ documents simultaneously would overwhelm it.
-
-### Immutable String Handling
-
-Old Automerge documents may store text content as `RawString` (immutable) instead of the collaborative text CRDT. You can't `splice` into these. The codebase handles this with `updateTextContent()` which detects the type and either splices or assigns directly, and a nuclear path in `updateRemoteFile()` that recreates the entire document if needed.
-
-## On-Disk Layout
-
-```
-your-project/
-  .pushwork/
-    config.json        ← local config overrides
-    snapshot.json      ← change-detection baseline (paths, URLs, heads)
-    automerge/         ← Automerge document binary storage
-
-~/.pushwork/
-  config.json          ← global user-level config
-```
-
-## Key Dependencies
-
-| Package | Purpose |
-|---|---|
-| `@automerge/automerge` | Core CRDT engine: splice, changeAt, RawString |
-| `@automerge/automerge-repo` | Repo, DocHandle, document lifecycle management |
-| `@automerge/automerge-repo-network-websocket` | WebSocket transport to relay server |
-| `@automerge/automerge-repo-storage-nodefs` | Local filesystem persistence for Automerge docs |
-| `@commander-js/extra-typings` | CLI command framework |
-| `diff` | Character-level diffing to feed `A.splice()` |
-| `glob` | Recursive filesystem enumeration |
-| `ignore` | Gitignore-style pattern matching for excludes |

package/CLAUDE.md

@@ -1,141 +0,0 @@
-# Pushwork - Claude's Notes
-
-Always update this file as you learn new things about the codebase — patterns, pitfalls, performance considerations, architectural decisions. This is your persistent memory across sessions.
-
-## What to do after changing code
-
-Always run `npm run build` (which runs `tsc`) after finishing changes to verify compilation.
-
-## Code style
-
-- `src/core/sync-engine.ts` and `src/commands.ts` use tabs for indentation
-- `src/utils/network-sync.ts` and `src/cli.ts` use 2-space indentation
-- Adding a new CLI command requires changes in 4 places: types (`src/types/config.ts` for options interface), engine (`src/core/sync-engine.ts` for method), commands (`src/commands.ts` for command function), CLI (`src/cli.ts` for registration + import)
-
-## What pushwork is
-
-Pushwork is a CLI tool for bidirectional file synchronization using Automerge CRDTs. It maps a local filesystem directory to a tree of Automerge documents, syncing changes in both directions through a relay server. Multiple users can edit the same files and changes merge automatically without conflicts.
-
-## Architecture overview
-
-```
-CLI (cli.ts) -> Commands (commands.ts) -> SyncEngine (core/sync-engine.ts)
-                                              |
-                                    +---------+---------+
-                                    |         |         |
-                              ChangeDetector  |    MoveDetector
-                                         SnapshotManager
-```
-
-### Key files
-
-- `src/cli.ts` - Commander.js CLI entry point, defines all commands
-- `src/commands.ts` - Command implementations, `setupCommandContext()` is the shared setup
-- `src/core/sync-engine.ts` - The heart of the system. Two-phase sync: push local changes, then pull remote changes
-- `src/core/change-detection.ts` - Compares local filesystem state against snapshot to find changes
-- `src/core/move-detection.ts` - Detects file renames/moves by content similarity
-- `src/core/snapshot.ts` - Manages `.pushwork/snapshot.json`, tracks what's been synced
-- `src/core/config.ts` - Config loading/merging (defaults < global < local)
-- `src/utils/text-diff.ts` - `spliceText()` for character-level CRDT edits, `updateTextContent()` for handling legacy immutable strings, `readDocContent()` for normalizing content reads
-
-### Type definitions
-
-- `src/types/documents.ts` - FileDocument, DirectoryDocument, DirectoryEntry
-- `src/types/config.ts` - DirectoryConfig, GlobalConfig, all CLI option interfaces
-- `src/types/snapshot.ts` - SyncSnapshot, SnapshotFileEntry, SyncResult
-
-## How sync works
-
-### Data model
-
-Every file becomes an Automerge document (`FileDocument`) with content stored as either collaborative text (for text files, supporting character-level merge) or raw bytes (for binary files). Directories become `DirectoryDocument`s containing a `docs` array of `{name, type, url}` entries pointing to children. The whole thing forms a tree rooted at one directory document.
-
-### Two-phase sync
-
-1. **Push** (local -> remote): Detect local filesystem changes vs snapshot. New files get new Automerge docs. Modified files get spliced. Deleted files are removed from their parent directory document (the orphaned doc is left as-is).
-2. **Network sync**: Wait for documents to reach the relay server, level-by-level deepest-first (children before parents).
-3. **Pull** (remote -> local): Re-detect changes after network sync. Write remote-only changes to the local filesystem.
-
-### Snapshot
-
-The snapshot (`.pushwork/snapshot.json`) records:
-- `rootDirectoryUrl` - the root Automerge document URL
-- `files` - map of relative path -> `{url, head}` for every tracked file
-- `directories` - map of relative path -> `{url, head}` for every tracked directory
-
-The `head` (Automerge document heads) is how change detection works: if a document's current heads differ from the snapshot heads, it has changed.
-
-### Versioned URLs
-
-Automerge URLs can include heads (e.g. `automerge:docid#head1,head2`). Pushwork stores versioned URLs in directory entries so clients can fetch the exact version. `getPlainUrl()` strips heads when you need a mutable handle; `getVersionedUrl()` adds current heads.
-
-## Immutable string handling
-
-Old Automerge documents may store text content as `RawString` (aka `ImmutableString`) instead of the collaborative text CRDT. You can't `splice` into these. Two strategies:
-
-1. **`updateTextContent()`** - Inside a change callback, detects if the field is a regular string (splice-able) or legacy immutable (assign directly to convert it).
-2. **`updateRemoteFile()` nuclear path** - If `A.isImmutableString(content)` is true, throws away the old document entirely, creates a brand new one with proper mutable text, and replaces the entry in the parent directory via `replaceFileInDirectory()`.
-
-`readDocContent()` normalizes `RawString` to plain strings when reading.
-
-## CLI commands
-
-- `pushwork init [path]` - Initialize, creates root directory document
-- `pushwork clone <url> <path>` - Clone from an Automerge URL
-- `pushwork sync [path]` - Full bidirectional sync (default: force mode — uses default config, preserves snapshot for incremental change detection)
-  - `--dry-run` - Preview only
-  - `--gentle` - Use merged config instead of defaults
-  - `--nuclear` - Recreate all Automerge documents from scratch (except root)
-  - `--force` - Silently accepted for backwards compatibility (does nothing, force is now the default)
-- `pushwork track <url> [path]` - Set root directory URL without full init (creates minimal `.pushwork/snapshot.json`). `root` is a hidden alias.
-- `pushwork commit [path]` - Save to Automerge docs without network sync
-- `pushwork status [path]` - Show sync status
-- `pushwork diff [path]` - Show changes
-- `pushwork url [path]` - Print root Automerge URL
-- `pushwork ls [path]` - List tracked files
-- `pushwork config [path]` - View config
-- `pushwork watch [path]` - Watch + build + sync loop
-- `pushwork rm [path]` - Remove local `.pushwork` data
-
-## Config
-
-Stored in `.pushwork/config.json` (local) and `~/.pushwork/config.json` (global). Merged: defaults < global < local.
-
-Key fields:
-- `sync_enabled: boolean` - Whether to do network sync
-- `sync_server: string` - WebSocket relay URL (default: `wss://subduction.sync.inkandswitch.com`)
-- `exclude_patterns: string[]` - Gitignore-style patterns (default: `.git`, `node_modules`, `*.tmp`, `.pushwork`, `.DS_Store`)
-- `sync.move_detection_threshold: number` - Similarity threshold for move detection (0-1, default 0.7)
-
-## Network sync details (Subduction)
-
-Pushwork uses Subduction for network sync. Subduction replaces the old `BrowserWebSocketClientAdapter` with a Subduction transport layer that handles sync automatically.
-
-- **Repo setup** (`src/utils/repo-factory.ts`): Creates a `WebCryptoSigner`, wraps `NodeFSStorageAdapter` in `SubductionStorageBridge`, hydrates `Subduction`, and calls `connectDiscover()` to the sync server. The `Repo` receives `{ subduction, storage }` instead of `{ storage, network }`.
-- **Sync verification**: Uses head-stability polling instead of `StorageId`-based `getSyncInfo()`. Both `waitForSync()` and `waitForBidirectionalSync()` poll document heads until they stabilize.
-- Uses `waitForSync()` to verify documents reach the server by polling head stability
-- Uses `waitForBidirectionalSync()` to poll until document heads stabilize (no more incoming changes)
-  - Accepts optional `handles` param to check only specific handles instead of full tree traversal (used post-push in `sync()`)
-  - Timeout scales dynamically: `max(timeoutMs, 5000 + docCount * 50)` so large trees don't prematurely time out
-  - Tree traversal (`collectHeadsRecursive`) fetches siblings concurrently via `Promise.all`
-- Documents sync level-by-level, deepest first, so children are on the server before their parents
-- `handlesByPath` map tracks which documents changed and need syncing
-- Default sync server: `wss://subduction.sync.inkandswitch.com`
-
-## Leaf-first ordering
-
-`pushLocalChanges()` processes directories deepest-first via `batchUpdateDirectory()`, propagating subdirectory URL updates as it walks up toward the root. This ensures directory entries always point to the latest version of their children.
-
-## The `changeWithOptionalHeads` helper
-
-Used throughout sync-engine: if heads are available, calls `handle.changeAt(heads, cb)` to branch from a known version; otherwise falls back to `handle.change(cb)`. This is important for conflict-free merging when multiple peers are editing.
-
-## Performance pitfalls
-
-- **Avoid splicing large text deletions.** Automerge text CRDTs track every character as an individual op. `A.splice(doc, path, 0, largeString.length)` to clear a large file is O(n) in CRDT ops and very slow. This is why `deleteRemoteFile()` no longer clears content — it just lets the document become orphaned when removed from its parent directory.
-- **Avoid diffing artifact files.** `diffChars()` is O(n*m) and pointless for artifact directories since they use RawString (immutable snapshots). Artifact files should always be replaced with a fresh document rather than diffed+spliced. This applies to `updateRemoteFile()`, `applyMoveToRemote()`, and change detection. `ChangeDetector` skips `getContentAtHead()` and `getCurrentRemoteContent()` for artifact paths — it uses a SHA-256 `contentHash` stored in the snapshot to detect local changes, and checks heads to detect remote changes. If neither changed, the artifact is skipped entirely. The `contentHash` field on `SnapshotFileEntry` is optional and only populated for artifact files.
-- **Sync timeout recovery.** `waitForSync()` returns `{ failed: DocHandle[] }` instead of throwing. When documents fail to sync (timeout or unavailable), `recreateFailedDocuments()` creates new Automerge docs with the same content, updates snapshot entries and parent directory references, then retries once. If documents still fail after recreation, it's reported as an error (not a warning) so the sync shows as "PARTIAL" rather than "SYNCED".
-- **Document availability during clone.** `repo.find()` rejects with "Document X is unavailable" if the sync server doesn't have the document yet. `DocHandle.doc()` is synchronous and throws if the handle isn't ready. For clone scenarios, `sync()` retries `repo.find()` for the root document with exponential backoff (up to 6 attempts). `ChangeDetector.findDocument()` wraps `repo.find()` + `doc()` with retry logic for all document fetches during change detection.
-- **Server load.** `waitForSync` processes documents in batches of 10 (`SYNC_BATCH_SIZE`) to avoid flooding the server with concurrent sync messages. Without batching, syncing 100+ documents simultaneously can overwhelm the sync server.
-- **`waitForBidirectionalSync` on large trees.** Full tree traversal (`getAllDocumentHeads`) is expensive because it `repo.find()`s every document. For post-push stabilization, pass the `handles` option to only check documents that actually changed. The initial pre-pull call still needs the full scan to discover remote changes. The dynamic timeout adds the first scan's duration on top of the base timeout, since the first scan is just establishing baseline — its duration shouldn't count against stability-wait time.
-- **Versioned URLs and `repo.find()`.** `repo.find(versionedUrl)` returns a view handle whose `.heads()` returns the VERSION heads, not the current document heads. Always use `getPlainUrl()` when you need the current/mutable state. The snapshot head update loop at the end of `sync()` must use `getPlainUrl(snapshotEntry.url)` — without this, artifact directories (which store versioned URLs) get stale heads written to the snapshot, causing `changeAt()` to fork from the wrong point on the next sync. This was the root cause of the artifact deletion resurrection bug: `batchUpdateDirectory` would `changeAt` from an empty directory state where the file entry didn't exist yet, so the splice found nothing to delete.

package/README.md

@@ -1,221 +0,0 @@
-# Pushwork
-
-Bidirectional file synchronization using Automerge CRDTs for conflict-free collaborative editing.
-
-## Features
-
-- **Conflict-Free Sync**: Automatic conflict resolution using Automerge CRDTs
-- **Real-time Collaboration**: Multiple users can edit the same files simultaneously
-- **Intelligent Move Detection**: Detects file renames and moves based on content similarity
-- **Offline Support**: Works offline and gracefully handles network interruptions
-- **Cross-Platform**: Runs on Windows, macOS, and Linux
-
-## Installation
-
-```bash
-pnpm install
-pnpm run build
-pnpm link --global
-```
-
-Requires: Node.js 18+, pnpm 8.15.0+
-
-## Quick Start
-
-```bash
-# Initialize a directory
-pushwork init ./my-project
-
-# Clone an existing repository
-pushwork clone <automerge-url> ./project
-
-# Sync changes
-pushwork sync
-
-# Check status
-pushwork status
-
-# Get shareable URL
-pushwork url
-```
-
-## Commands
-
-### Core Commands
-
-**`init [path]`** - Initialize sync in a directory
-
-- `--sync-server <url>` - Custom sync server URL
-- `--sync-server-storage-id <id>` - Custom storage ID
-- `--debug` - Export performance flame graphs
-
-**`clone <url> <path>`** - Clone an existing synced directory
-
-- `--force` - Overwrite existing directory
-- `--sync-server <url>` - Custom sync server URL
-- `--sync-server-storage-id <id>` - Custom storage ID
-
-**`sync [path]`** - Run bidirectional synchronization
-
-- `--dry-run` - Preview changes without applying
-- `--verbose` - Show detailed progress
-- `--debug` - Export performance flame graphs
-
-**`status [path]`** - Show sync status and repository info
-
-- `--verbose` - Show detailed status including all tracked files
-
-**`commit [path]`** - Commit local changes without network sync
-
-- `--dry-run` - Preview what would be committed
-- `--debug` - Export performance flame graphs
-
-### Utility Commands
-
-**`diff [path]`** - Show differences between local and remote
-
-- `--name-only` - Show only changed file names
-
-**`url [path]`** - Show the Automerge root URL for sharing
-
-**`ls [path]`** - List tracked files
-
-- `--long` - Show Automerge URLs
-
-**`config [path]`** - View or edit configuration
-
-- `--list` - Show full configuration
-- `--get <key>` - Get specific config value (dot notation)
-
-**`rm [path]`** - Remove local pushwork data
-
-**`watch [path]`** - Watch directory, build, and sync automatically
-
-- `--script <command>` - Build script (default: "pnpm build")
-- `--dir <dir>` - Directory to watch (default: "src")
-- `--verbose` - Show build output
-
-**`log [path]`** - Show sync history _(experimental, limited functionality)_
-
-**`checkout <sync-id> [path]`** - Restore to previous sync _(not yet implemented)_
-
-## Configuration
-
-Configuration is stored in `.pushwork/config.json`:
-
-```json
-{
-  "sync_server": "wss://sync3.automerge.org",
-  "sync_server_storage_id": "3760df37-a4c6-4f66-9ecd-732039a9385d",
-  "sync_enabled": true,
-  "defaults": {
-    "exclude_patterns": [".git", "node_modules", "*.tmp", ".pushwork"],
-    "large_file_threshold": "100MB"
-  },
-  "diff": {
-    "show_binary": false
-  },
-  "sync": {
-    "move_detection_threshold": 0.8,
-    "prompt_threshold": 0.5,
-    "auto_sync": false,
-    "parallel_operations": 4
-  }
-}
-```
-
-## How It Works
-
-Pushwork uses Automerge CRDTs for automatic conflict resolution:
-
-- **Text files**: Character-level merging preserves all changes
-- **Binary files**: Last-writer-wins with automatic convergence
-- **Directories**: Additive merging supports simultaneous file creation
-
-Sync process:
-
-1. **Push**: Apply local changes to Automerge documents
-2. **Pull**: Apply remote changes to local filesystem
-3. **Convergence**: All repositories reach identical state
-
-State tracking:
-
-- `.pushwork/snapshot.json` - Tracks sync state and file mappings
-- `.pushwork/config.json` - Configuration settings
-- Content-based change detection using Automerge document heads
-
-### Document Schema
-
-**File Document:**
-
-```typescript
-{
-  "@patchwork": { type: "file" };
-  name: string;
-  extension: string;
-  mimeType: string;
-  content: string | Uint8Array;
-  metadata: {
-    permissions: number;
-  };
-}
-```
-
-**Directory Document:**
-
-```typescript
-{
-  "@patchwork": { type: "folder" };
-  docs: Array<{
-    name: string;
-    type: "file" | "folder";
-    url: AutomergeUrl;
-  }>;
-  lastSyncAt?: number;
-}
-```
-
-## Development
-
-### Setup
-
-```bash
-git clone <repository-url>
-cd pushwork
-pnpm install
-pnpm run build
-pnpm run dev          # Watch mode
-pnpm test             # Run tests
-pnpm run test:watch   # Watch mode for tests
-```
-
-### Project Structure
-
-```
-src/
-├── cli/        # Command-line interface
-├── core/       # Core sync engine
-├── config/     # Configuration management
-├── tracing/    # Performance tracing
-├── types/      # TypeScript type definitions
-└── utils/      # Shared utilities
-```
-
-### Testing
-
-```bash
-pnpm test                                              # Unit tests
-./test/run-tests.sh                                    # All integration tests
-./test/integration/conflict-resolution-test.sh         # Specific test
-```
-
-### Profiling
-
-```bash
-pushwork sync --debug                                  # Export flame graphs
-clinic flame --collect-only -- node --enable-source-maps --prof $(pnpm root -g)/pushwork/dist/cli.js sync
-```
-
-## License
-
-MIT License

package/babel.config.js

@@ -1,5 +0,0 @@
-module.exports = {
-  presets: [
-    ['@babel/preset-env', { targets: { node: 'current' } }]
-  ]
-};