pushwork 2.0.0-a.sub.1 → 2.0.0-preview.2

package/test/integration/init-sync.test.ts

@@ -1,89 +0,0 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-import * as tmp from "tmp";
-import { execSync } from "child_process";
-import { SnapshotManager } from "../../src/core";
-
-describe("Init Command Integration", () => {
-  let tmpDir: string;
-  let cleanup: () => void;
-  const pushworkCmd = `node "${path.join(__dirname, "../../dist/cli.js")}"`;
-
-  beforeAll(() => {
-    // Build the project before running tests
-    execSync("pnpm build", { cwd: path.join(__dirname, "../.."), stdio: "pipe" });
-  });
-
-  beforeEach(() => {
-    const tmpObj = tmp.dirSync({ unsafeCleanup: true });
-    tmpDir = tmpObj.name;
-    cleanup = tmpObj.removeCallback;
-  });
-
-  afterEach(async () => {
-    cleanup();
-  });
-
-  describe("Initial Sync", () => {
-    it("should sync existing files during init", async () => {
-      // Create some files before initializing
-      await fs.writeFile(path.join(tmpDir, "file1.txt"), "Hello, World!");
-      await fs.writeFile(path.join(tmpDir, "file2.txt"), "Another file");
-      await fs.mkdir(path.join(tmpDir, "subdir"));
-      await fs.writeFile(
-        path.join(tmpDir, "subdir", "nested.txt"),
-        "Nested content"
-      );
-
-      // Run pushwork init
-      execSync(`${pushworkCmd} init "${tmpDir}"`, { stdio: "pipe" });
-
-      // Verify snapshot was created with file entries
-      const snapshotManager = new SnapshotManager(tmpDir);
-      const snapshot = await snapshotManager.load();
-      expect(snapshot).not.toBeNull();
-      expect(snapshot!.files.size).toBeGreaterThanOrEqual(3);
-      expect(snapshot!.files.has("file1.txt")).toBe(true);
-      expect(snapshot!.files.has("file2.txt")).toBe(true);
-      expect(snapshot!.files.has("subdir/nested.txt")).toBe(true);
-    });
-
-    it("should handle empty directory during init", async () => {
-      // Run pushwork init on empty directory
-      execSync(`${pushworkCmd} init "${tmpDir}"`, { stdio: "pipe" });
-
-      // Verify snapshot was created (even if empty)
-      const snapshotManager = new SnapshotManager(tmpDir);
-      const snapshot = await snapshotManager.load();
-      expect(snapshot).not.toBeNull();
-      expect(snapshot!.files.size).toBe(0);
-    });
-
-    it("should respect exclude patterns during initial sync", async () => {
-      // Create files, including some that should be excluded by default
-      await fs.writeFile(path.join(tmpDir, "included.txt"), "Include me");
-      await fs.mkdir(path.join(tmpDir, "node_modules"));
-      await fs.writeFile(
-        path.join(tmpDir, "node_modules", "package.json"),
-        "{}"
-      );
-      await fs.mkdir(path.join(tmpDir, ".git"));
-      await fs.writeFile(
-        path.join(tmpDir, ".git", "config"),
-        "[core]"
-      );
-
-      // Run pushwork init
-      execSync(`${pushworkCmd} init "${tmpDir}"`, { stdio: "pipe" });
-
-      // Verify snapshot only contains included file
-      const snapshotManager = new SnapshotManager(tmpDir);
-      const snapshot = await snapshotManager.load();
-      expect(snapshot).not.toBeNull();
-      expect(snapshot!.files.has("included.txt")).toBe(true);
-      // node_modules and .git should be excluded by default
-      expect(snapshot!.files.has("node_modules/package.json")).toBe(false);
-      expect(snapshot!.files.has(".git/config")).toBe(false);
-    });
-  });
-});

package/test/integration/manual-sync-test.sh

@@ -1,84 +0,0 @@
-#!/bin/bash
-set -x  # Print commands as they execute
-set -e  # Exit on error
-
-# Get absolute path to pushwork CLI
-PUSHWORK_ROOT="$(cd "$(dirname "$0")/../.." && pwd)"
-PUSHWORK_CLI="$PUSHWORK_ROOT/dist/cli.js"
-
-echo "Pushwork CLI: $PUSHWORK_CLI"
-
-# Create temp directory
-TESTDIR=$(mktemp -d)
-echo "Test directory: $TESTDIR"
-
-REPO_A="$TESTDIR/repo-a"
-REPO_B="$TESTDIR/repo-b"
-
-mkdir -p "$REPO_A"
-mkdir -p "$REPO_B"
-
-# Step 1: Create initial file in repo A
-echo "=== Step 1: Creating initial file in repo A ==="
-echo "initial content" > "$REPO_A/test.txt"
-cat "$REPO_A/test.txt"
-
-# Step 2: Initialize repo A
-echo "=== Step 2: Initializing repo A ==="
-cd "$REPO_A"
-node "$PUSHWORK_CLI" init .
-sleep 1
-
-# Step 3: Get root URL
-echo "=== Step 3: Getting root URL from repo A ==="
-ROOT_URL=$(node "$PUSHWORK_CLI" url)
-echo "Root URL: $ROOT_URL"
-
-# Step 4: Clone to repo B
-echo "=== Step 4: Cloning to repo B ==="
-cd "$TESTDIR"
-node "$PUSHWORK_CLI" clone "$ROOT_URL" "$REPO_B"
-sleep 1
-
-# Step 5: Verify initial state
-echo "=== Step 5: Verifying initial state ==="
-echo "Content in A:"
-cat "$REPO_A/test.txt"
-echo "Content in B:"
-cat "$REPO_B/test.txt"
-
-# Step 6: Modify file in repo A
-echo "=== Step 6: Modifying file in repo A ==="
-echo "modified content" > "$REPO_A/test.txt"
-echo "New content in A:"
-cat "$REPO_A/test.txt"
-
-# Step 7: Sync repo A (THIS IS WHERE IT MIGHT HANG)
-echo "=== Step 7: Syncing repo A ==="
-cd "$REPO_A"
-echo "Running sync in A at $(date)..."
-timeout 10 node "$PUSHWORK_CLI" sync || echo "SYNC A TIMED OUT!"
-echo "Sync A completed at $(date)"
-sleep 1
-
-# Step 8: Sync repo B
-echo "=== Step 8: Syncing repo B ==="
-cd "$REPO_B"
-echo "Running sync in B at $(date)..."
-timeout 10 node "$PUSHWORK_CLI" sync || echo "SYNC B TIMED OUT!"
-echo "Sync B completed at $(date)"
-sleep 1
-
-# Step 9: Verify final state
-echo "=== Step 9: Verifying final state ==="
-echo "Final content in A:"
-cat "$REPO_A/test.txt"
-echo "Final content in B:"
-cat "$REPO_B/test.txt"
-
-# Cleanup
-echo "=== Cleanup ==="
-echo "Test directory: $TESTDIR"
-echo "To inspect manually: cd $TESTDIR"
-# rm -rf "$TESTDIR"
-

package/test/integration/sync-deletion.test.ts

@@ -1,280 +0,0 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-import { tmpdir } from "os";
-import {
-  readFileContent,
-  writeFileContent,
-  removePath,
-  pathExists,
-} from "../../src/utils";
-import { SnapshotManager } from "../../src/core/snapshot";
-
-describe("Sync Engine Deletion Integration", () => {
-  let testDir: string;
-  let snapshotManager: SnapshotManager;
-
-  beforeEach(async () => {
-    testDir = await fs.mkdtemp(path.join(tmpdir(), "sync-deletion-test-"));
-    snapshotManager = new SnapshotManager(testDir);
-  });
-
-  afterEach(async () => {
-    await fs.rm(testDir, { recursive: true, force: true });
-  });
-
-  describe("Deletion Detection Logic", () => {
-    it("should properly detect local file deletions", async () => {
-      // Create initial state
-      const filePath = path.join(testDir, "will-be-deleted.ts");
-      const content = "interface ToDelete { id: number; }";
-      await writeFileContent(filePath, content);
-
-      // Create snapshot representing the "before" state
-      const snapshot = snapshotManager.createEmpty();
-      snapshotManager.updateFileEntry(snapshot, "will-be-deleted.ts", {
-        path: filePath,
-        url: "automerge:deletion-test" as any,
-        head: ["before-deletion"] as any,
-        extension: "ts",
-        mimeType: "text/typescript",
-      });
-
-      // Verify initial state
-      expect(await pathExists(filePath)).toBe(true);
-      expect(snapshot.files.has("will-be-deleted.ts")).toBe(true);
-
-      // Simulate user deleting the file
-      await removePath(filePath);
-
-      // File should be gone from filesystem but still in snapshot
-      expect(await pathExists(filePath)).toBe(false);
-      expect(snapshot.files.has("will-be-deleted.ts")).toBe(true);
-    });
-
-    it("should handle multiple file deletions correctly", async () => {
-      const testFiles = [
-        { name: "delete1.ts", content: "interface One { x: number; }" },
-        { name: "delete2.js", content: "const two = 'value';" },
-        { name: "delete3.json", content: '{"three": true}' },
-      ];
-
-      const snapshot = snapshotManager.createEmpty();
-
-      // Create all files and add to snapshot
-      for (const file of testFiles) {
-        const filePath = path.join(testDir, file.name);
-        await writeFileContent(filePath, file.content);
-
-        snapshotManager.updateFileEntry(snapshot, file.name, {
-          path: filePath,
-          url: `automerge:${file.name}` as any,
-          head: [`head-${file.name}`] as any,
-          extension: path.extname(file.name).slice(1),
-          mimeType: file.name.endsWith(".ts")
-            ? "text/typescript"
-            : "text/plain",
-        });
-      }
-
-      expect(snapshot.files.size).toBe(3);
-
-      // Delete all files
-      for (const file of testFiles) {
-        const filePath = path.join(testDir, file.name);
-        await removePath(filePath);
-      }
-
-      // Verify all files are gone from filesystem
-      for (const file of testFiles) {
-        const filePath = path.join(testDir, file.name);
-        expect(await pathExists(filePath)).toBe(false);
-      }
-
-      // Snapshot should still have entries (until sync processes them)
-      expect(snapshot.files.size).toBe(3);
-
-      // Simulate sync engine processing the deletions
-      for (const file of testFiles) {
-        snapshotManager.removeFileEntry(snapshot, file.name);
-      }
-
-      expect(snapshot.files.size).toBe(0);
-    });
-  });
-
-  describe("Deletion Timing and Race Conditions", () => {
-    it("should handle rapid create-modify-delete sequences", async () => {
-      const filePath = path.join(testDir, "rapid-changes.ts");
-      const snapshot = snapshotManager.createEmpty();
-
-      for (let i = 0; i < 3; i++) {
-        // Create
-        const content = `interface Cycle${i} { value: ${i}; }`;
-        await writeFileContent(filePath, content);
-
-        // Add to snapshot
-        snapshotManager.updateFileEntry(snapshot, "rapid-changes.ts", {
-          path: filePath,
-          url: `automerge:cycle-${i}` as any,
-          head: [`head-${i}`] as any,
-          extension: "ts",
-          mimeType: "text/typescript",
-        });
-
-        // Modify
-        const modifiedContent = content + `\n// Modified in cycle ${i}`;
-        await writeFileContent(filePath, modifiedContent);
-
-        // Delete
-        await removePath(filePath);
-
-        // Verify deletion
-        expect(await pathExists(filePath)).toBe(false);
-
-        // Clean up snapshot
-        snapshotManager.removeFileEntry(snapshot, "rapid-changes.ts");
-      }
-    });
-
-    it("should handle deletion during content modification attempts", async () => {
-      const filePath = path.join(testDir, "modify-delete-race.ts");
-      const initialContent = "interface Race { test: boolean; }";
-
-      // Create initial file
-      await writeFileContent(filePath, initialContent);
-
-      // Start modification and deletion concurrently
-      const modifyPromise = writeFileContent(
-        filePath,
-        initialContent + "\n// Modified"
-      );
-      const deletePromise = (async () => {
-        // Small delay to let modification start
-        await new Promise((resolve) => setTimeout(resolve, 1));
-        await removePath(filePath);
-      })();
-
-      // Wait for both operations to complete
-      await Promise.allSettled([modifyPromise, deletePromise]);
-
-      // File should be deleted regardless of modification timing
-      expect(await pathExists(filePath)).toBe(false);
-    });
-  });
-
-  describe("Directory Structure Impact", () => {
-    it("should handle deletion of files in nested directories", async () => {
-      // Create nested structure
-      const nestedDir = path.join(testDir, "src", "components");
-      const filePath = path.join(nestedDir, "Button.tsx");
-      const content = "export const Button = () => <button>Click</button>;";
-
-      await fs.mkdir(nestedDir, { recursive: true });
-      await writeFileContent(filePath, content);
-
-      const snapshot = snapshotManager.createEmpty();
-      snapshotManager.updateFileEntry(snapshot, "src/components/Button.tsx", {
-        path: filePath,
-        url: "automerge:nested-button" as any,
-        head: ["nested-head"] as any,
-        extension: "tsx",
-        mimeType: "text/tsx",
-      });
-
-      // Delete just the file (not the directories)
-      await removePath(filePath);
-
-      // File should be gone, directories should remain
-      expect(await pathExists(filePath)).toBe(false);
-      expect(await pathExists(nestedDir)).toBe(true);
-      expect(await pathExists(path.join(testDir, "src"))).toBe(true);
-
-      // Simulate snapshot cleanup
-      snapshotManager.removeFileEntry(snapshot, "src/components/Button.tsx");
-      expect(snapshot.files.size).toBe(0);
-    });
-
-    it("should handle deletion of entire directory trees", async () => {
-      // Create multiple files in nested structure
-      const testStructure = [
-        "src/utils/helpers.ts",
-        "src/utils/constants.ts",
-        "src/components/Button.tsx",
-        "src/components/Input.tsx",
-        "src/types/index.ts",
-      ];
-
-      const snapshot = snapshotManager.createEmpty();
-
-      for (const relativePath of testStructure) {
-        const fullPath = path.join(testDir, relativePath);
-        await fs.mkdir(path.dirname(fullPath), { recursive: true });
-        await writeFileContent(fullPath, `// Content for ${relativePath}`);
-
-        snapshotManager.updateFileEntry(snapshot, relativePath, {
-          path: fullPath,
-          url: `automerge:${relativePath.replace(/[\/\.]/g, "-")}` as any,
-          head: [`head-${relativePath}`] as any,
-          extension: path.extname(relativePath).slice(1),
-          mimeType: "text/typescript",
-        });
-      }
-
-      expect(snapshot.files.size).toBe(5);
-
-      // Delete entire src directory
-      await removePath(path.join(testDir, "src"));
-
-      // Verify all files and directories are gone
-      for (const relativePath of testStructure) {
-        const fullPath = path.join(testDir, relativePath);
-        expect(await pathExists(fullPath)).toBe(false);
-      }
-      expect(await pathExists(path.join(testDir, "src"))).toBe(false);
-
-      // Simulate snapshot cleanup for all files
-      for (const relativePath of testStructure) {
-        snapshotManager.removeFileEntry(snapshot, relativePath);
-      }
-
-      expect(snapshot.files.size).toBe(0);
-    });
-  });
-
-  describe("Error Recovery and Edge Cases", () => {
-    it("should handle deletion of non-existent files gracefully", async () => {
-      const nonExistentPath = path.join(testDir, "never-existed.ts");
-
-      // Attempt to delete non-existent file (should not throw)
-      await expect(removePath(nonExistentPath)).resolves.not.toThrow();
-
-      // Attempt to remove from snapshot (should not throw)
-      const snapshot = snapshotManager.createEmpty();
-      expect(() => {
-        snapshotManager.removeFileEntry(snapshot, "never-existed.ts");
-      }).not.toThrow();
-    });
-
-    it("should provide debugging info for deletion failures", async () => {
-      const debugFilePath = path.join(testDir, "debug-deletion.ts");
-      const content = "interface Debug { info: string; }";
-
-      try {
-        // Create file
-        await writeFileContent(debugFilePath, content);
-
-        // Verify file exists and is readable
-        const readBack = await readFileContent(debugFilePath);
-        expect(readBack).toBe(content);
-
-        // Delete file
-        await removePath(debugFilePath);
-
-        expect(await pathExists(debugFilePath)).toBe(false);
-      } catch (error) {
-        console.error(`❌ Deletion test failed:`, error);
-        throw error;
-      }
-    });
-  });
-});