pushwork 1.0.4 → 1.0.7

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

@@ -0,0 +1,89 @@
+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/sync-deletion.test.ts

@@ -8,8 +8,6 @@ import {
   pathExists,
 } from "../../src/utils";
 import { SnapshotManager } from "../../src/core/snapshot";
-import { ChangeDetector } from "../../src/core/change-detection";
-import { ChangeType } from "../../src/types";
 
 describe("Sync Engine Deletion Integration", () => {
   let testDir: string;
@@ -26,8 +24,6 @@ describe("Sync Engine Deletion Integration", () => {
 
   describe("Deletion Detection Logic", () => {
     it("should properly detect local file deletions", async () => {
-      console.log("\n🧪 Testing Local File Deletion Detection");
-
       // Create initial state
       const filePath = path.join(testDir, "will-be-deleted.ts");
       const content = "interface ToDelete { id: number; }";
@@ -43,27 +39,19 @@ describe("Sync Engine Deletion Integration", () => {
         mimeType: "text/typescript",
       });
 
-      console.log(`📄 Created file: ${filePath}`);
-      console.log(`📸 Snapshot has ${snapshot.files.size} files`);
-
       // 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);
-      console.log(`🗑️  File deleted from filesystem`);
 
       // 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);
-
-      console.log(`✅ Deletion properly detected`);
     });
 
     it("should handle multiple file deletions correctly", async () => {
-      console.log("\n🧪 Testing Multiple File Deletions");
-
       const testFiles = [
         { name: "delete1.ts", content: "interface One { x: number; }" },
         { name: "delete2.js", content: "const two = 'value';" },
@@ -86,8 +74,6 @@ describe("Sync Engine Deletion Integration", () => {
             ? "text/typescript"
             : "text/plain",
         });
-
-        console.log(`📄 Created: ${file.name}`);
       }
 
       expect(snapshot.files.size).toBe(3);
@@ -96,7 +82,6 @@ describe("Sync Engine Deletion Integration", () => {
       for (const file of testFiles) {
         const filePath = path.join(testDir, file.name);
         await removePath(filePath);
-        console.log(`🗑️  Deleted: ${file.name}`);
       }
 
       // Verify all files are gone from filesystem
@@ -111,28 +96,21 @@ describe("Sync Engine Deletion Integration", () => {
       // Simulate sync engine processing the deletions
       for (const file of testFiles) {
         snapshotManager.removeFileEntry(snapshot, file.name);
-        console.log(`📸 Removed from snapshot: ${file.name}`);
       }
 
       expect(snapshot.files.size).toBe(0);
-      console.log(`✅ Multiple deletions handled correctly`);
     });
   });
 
   describe("Deletion Timing and Race Conditions", () => {
     it("should handle rapid create-modify-delete sequences", async () => {
-      console.log("\n🧪 Testing Rapid Create-Modify-Delete Sequences");
-
       const filePath = path.join(testDir, "rapid-changes.ts");
       const snapshot = snapshotManager.createEmpty();
 
       for (let i = 0; i < 3; i++) {
-        console.log(`\n--- Cycle ${i + 1} ---`);
-
         // Create
         const content = `interface Cycle${i} { value: ${i}; }`;
         await writeFileContent(filePath, content);
-        console.log(`📄 Created with content: "${content}"`);
 
         // Add to snapshot
         snapshotManager.updateFileEntry(snapshot, "rapid-changes.ts", {
@@ -146,11 +124,9 @@ describe("Sync Engine Deletion Integration", () => {
         // Modify
         const modifiedContent = content + `\n// Modified in cycle ${i}`;
         await writeFileContent(filePath, modifiedContent);
-        console.log(`📝 Modified content`);
 
         // Delete
         await removePath(filePath);
-        console.log(`🗑️  Deleted`);
 
         // Verify deletion
         expect(await pathExists(filePath)).toBe(false);
@@ -158,19 +134,14 @@ describe("Sync Engine Deletion Integration", () => {
         // Clean up snapshot
         snapshotManager.removeFileEntry(snapshot, "rapid-changes.ts");
       }
-
-      console.log(`✅ Rapid sequences handled without errors`);
     });
 
     it("should handle deletion during content modification attempts", async () => {
-      console.log("\n🧪 Testing Deletion During Modification");
-
       const filePath = path.join(testDir, "modify-delete-race.ts");
       const initialContent = "interface Race { test: boolean; }";
 
       // Create initial file
       await writeFileContent(filePath, initialContent);
-      console.log(`📄 Created file with initial content`);
 
       // Start modification and deletion concurrently
       const modifyPromise = writeFileContent(
@@ -188,14 +159,11 @@ describe("Sync Engine Deletion Integration", () => {
 
       // File should be deleted regardless of modification timing
       expect(await pathExists(filePath)).toBe(false);
-      console.log(`✅ File properly deleted despite concurrent modification`);
     });
   });
 
   describe("Directory Structure Impact", () => {
     it("should handle deletion of files in nested directories", async () => {
-      console.log("\n🧪 Testing Nested Directory File Deletion");
-
       // Create nested structure
       const nestedDir = path.join(testDir, "src", "components");
       const filePath = path.join(nestedDir, "Button.tsx");
@@ -213,12 +181,8 @@ describe("Sync Engine Deletion Integration", () => {
         mimeType: "text/tsx",
       });
 
-      console.log(`📁 Created nested structure: ${nestedDir}`);
-      console.log(`📄 Created file: src/components/Button.tsx`);
-
       // Delete just the file (not the directories)
       await removePath(filePath);
-      console.log(`🗑️  Deleted file, kept directory structure`);
 
       // File should be gone, directories should remain
       expect(await pathExists(filePath)).toBe(false);
@@ -228,13 +192,9 @@ describe("Sync Engine Deletion Integration", () => {
       // Simulate snapshot cleanup
       snapshotManager.removeFileEntry(snapshot, "src/components/Button.tsx");
       expect(snapshot.files.size).toBe(0);
-
-      console.log(`✅ Nested file deletion handled correctly`);
     });
 
     it("should handle deletion of entire directory trees", async () => {
-      console.log("\n🧪 Testing Directory Tree Deletion");
-
       // Create multiple files in nested structure
       const testStructure = [
         "src/utils/helpers.ts",
@@ -258,15 +218,12 @@ describe("Sync Engine Deletion Integration", () => {
           extension: path.extname(relativePath).slice(1),
           mimeType: "text/typescript",
         });
-
-        console.log(`📄 Created: ${relativePath}`);
       }
 
       expect(snapshot.files.size).toBe(5);
 
       // Delete entire src directory
       await removePath(path.join(testDir, "src"));
-      console.log(`🗑️  Deleted entire src/ directory tree`);
 
       // Verify all files and directories are gone
       for (const relativePath of testStructure) {
@@ -278,58 +235,42 @@ describe("Sync Engine Deletion Integration", () => {
       // Simulate snapshot cleanup for all files
       for (const relativePath of testStructure) {
         snapshotManager.removeFileEntry(snapshot, relativePath);
-        console.log(`📸 Removed from snapshot: ${relativePath}`);
       }
 
       expect(snapshot.files.size).toBe(0);
-      console.log(`✅ Directory tree deletion handled correctly`);
     });
   });
 
   describe("Error Recovery and Edge Cases", () => {
     it("should handle deletion of non-existent files gracefully", async () => {
-      console.log("\n🧪 Testing Non-Existent File Deletion");
-
       const nonExistentPath = path.join(testDir, "never-existed.ts");
 
       // Attempt to delete non-existent file (should not throw)
       await expect(removePath(nonExistentPath)).resolves.not.toThrow();
-      console.log(`✅ Non-existent file deletion handled gracefully`);
 
       // Attempt to remove from snapshot (should not throw)
       const snapshot = snapshotManager.createEmpty();
       expect(() => {
         snapshotManager.removeFileEntry(snapshot, "never-existed.ts");
       }).not.toThrow();
-      console.log(`✅ Non-existent snapshot entry removal handled gracefully`);
     });
 
     it("should provide debugging info for deletion failures", async () => {
-      console.log("\n🧪 Deletion Debugging Information");
-
       const debugFilePath = path.join(testDir, "debug-deletion.ts");
       const content = "interface Debug { info: string; }";
 
       try {
         // Create file
         await writeFileContent(debugFilePath, content);
-        console.log(`📄 File created: ${debugFilePath}`);
-        console.log(`📏 File size: ${content.length} characters`);
 
         // Verify file exists and is readable
         const readBack = await readFileContent(debugFilePath);
-        console.log(`📖 File readable: ${typeof readBack === "string"}`);
-        console.log(`✅ Content matches: ${readBack === content}`);
+        expect(readBack).toBe(content);
 
         // Delete file
-        const deleteStart = Date.now();
         await removePath(debugFilePath);
-        const deleteTime = Date.now() - deleteStart;
 
-        console.log(`🗑️  Deletion completed in ${deleteTime}ms`);
-        console.log(
-          `🔍 File exists after deletion: ${await pathExists(debugFilePath)}`
-        );
+        expect(await pathExists(debugFilePath)).toBe(false);
       } catch (error) {
         console.error(`❌ Deletion test failed:`, error);
         throw error;

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

@@ -1,7 +1,7 @@
 import * as fs from "fs/promises";
 import * as path from "path";
 import * as tmp from "tmp";
-import { ConfigManager } from "../../src/config";
+import { ConfigManager } from "../../src/core";
 import { DirectoryConfig } from "../../src/types";
 
 describe("Sync Flow Integration", () => {
@@ -26,18 +26,9 @@ describe("Sync Flow Integration", () => {
       const testConfig: DirectoryConfig = {
         sync_server: "wss://test.server.com",
         sync_enabled: true,
-        defaults: {
-          exclude_patterns: [".git", "*.tmp"],
-          large_file_threshold: "1MB",
-        },
-        diff: {
-          show_binary: false,
-        },
+        exclude_patterns: [".git", "*.tmp"],
         sync: {
           move_detection_threshold: 0.8,
-          prompt_threshold: 0.5,
-          auto_sync: false,
-          parallel_operations: 2,
         },
       };
 
@@ -57,18 +48,9 @@ describe("Sync Flow Integration", () => {
       const localConfig: DirectoryConfig = {
         sync_server: "wss://local.server.com",
         sync_enabled: true,
-        defaults: {
-          exclude_patterns: [".git", "*.tmp"],
-          large_file_threshold: "5MB",
-        },
-        diff: {
-          show_binary: true,
-        },
+        exclude_patterns: [".git", "*.tmp"],
         sync: {
           move_detection_threshold: 0.9,
-          prompt_threshold: 0.6,
-          auto_sync: true,
-          parallel_operations: 1,
         },
       };
 
@@ -77,9 +59,7 @@ describe("Sync Flow Integration", () => {
       // Verify merged config
       const mergedConfig = await configManager.getMerged();
       expect(mergedConfig.sync_server).toBe("wss://local.server.com");
-      expect(mergedConfig.defaults?.exclude_patterns).toContain(".git");
-      expect(mergedConfig.defaults?.large_file_threshold).toBe("5MB");
-      expect(mergedConfig.diff?.show_binary).toBe(true);
+      expect(mergedConfig.exclude_patterns).toContain(".git");
       expect(mergedConfig.sync?.move_detection_threshold).toBe(0.9);
     });
   });

package/test/jest.setup.ts

@@ -0,0 +1,34 @@
+/**
+ * Jest setup file to mock ESM modules that don't work well with Jest
+ */
+
+// Mock chalk (ESM-only module)
+jest.mock("chalk", () => ({
+  __esModule: true,
+  default: new Proxy(
+    {},
+    {
+      get: (target, prop) => {
+        if (prop === "default") return target;
+        // Return a function that returns the input string unchanged
+        return (str: string) => str;
+      },
+    }
+  ),
+}));
+
+// Mock ora (ESM-only module)
+jest.mock("ora", () => ({
+  __esModule: true,
+  default: jest.fn(() => ({
+    start: jest.fn().mockReturnThis(),
+    stop: jest.fn().mockReturnThis(),
+    succeed: jest.fn().mockReturnThis(),
+    fail: jest.fn().mockReturnThis(),
+    warn: jest.fn().mockReturnThis(),
+    info: jest.fn().mockReturnThis(),
+    clear: jest.fn().mockReturnThis(),
+    text: "",
+  })),
+}));
+

package/test/unit/deletion-behavior.test.ts

@@ -9,18 +9,16 @@ import {
 } from "../../src/utils";
 import { SnapshotManager } from "../../src/core/snapshot";
 import { ChangeDetector } from "../../src/core/change-detection";
-import { ChangeType } from "../../src/types";
 
 describe("File Deletion Behavior", () => {
   let testDir: string;
   let snapshotManager: SnapshotManager;
-  let changeDetector: ChangeDetector;
 
   beforeEach(async () => {
     testDir = await fs.mkdtemp(path.join(tmpdir(), "deletion-test-"));
     snapshotManager = new SnapshotManager(testDir);
     // Create a minimal change detector for testing (without Automerge repo)
-    changeDetector = new ChangeDetector(null as any, testDir, []);
+    new ChangeDetector(null as any, testDir, []);
   });
 
   afterEach(async () => {
@@ -230,31 +228,22 @@ describe("File Deletion Behavior", () => {
 
   describe("Debug Information", () => {
     it("should provide detailed info about deletion behavior", async () => {
-      console.log("\n=== Deletion Behavior Debug Info ===");
-
       const filePath = path.join(testDir, "debug.txt");
       const content = "Debug test content";
 
-      console.log(`Test directory: ${testDir}`);
-      console.log(`File path: ${filePath}`);
-
       // Create file
       await writeFileContent(filePath, content);
-      console.log(`✅ File created successfully`);
 
       // Verify file content
       const readBack = await readFileContent(filePath);
-      console.log(`✅ File content verified: "${readBack}"`);
+      expect(readBack).toBe(content);
 
       // Delete file
       await removePath(filePath);
-      console.log(`✅ File deleted successfully`);
 
       // Verify deletion
       const exists = await pathExists(filePath);
-      console.log(`✅ File deletion verified: exists=${exists}`);
-
-      console.log("=== End Debug Info ===\n");
+      expect(exists).toBe(false);
     });
   });
 });

package/test/unit/enhanced-mime-detection.test.ts

@@ -6,7 +6,6 @@ import {
   isEnhancedTextFile,
   shouldForceAsText,
   getMimeType,
-  isTextFile,
 } from "../../src/utils";
 
 describe("Enhanced MIME Detection", () => {
@@ -27,19 +26,12 @@ describe("Enhanced MIME Detection", () => {
 
       // Standard MIME detection (broken)
       const standardMime = getMimeType(tsFile);
-      const standardIsText = await isTextFile(tsFile);
 
       // Enhanced MIME detection (fixed)
       const enhancedMime = getEnhancedMimeType(tsFile);
       const enhancedIsText = await isEnhancedTextFile(tsFile);
       const shouldForce = shouldForceAsText(tsFile);
 
-      console.log("TypeScript file (.ts) detection:");
-      console.log(`  Standard MIME: ${standardMime}, Text: ${standardIsText}`);
-      console.log(
-        `  Enhanced MIME: ${enhancedMime}, Text: ${enhancedIsText}, Force: ${shouldForce}`
-      );
-
       // Verify the fix
       expect(enhancedMime).toBe("text/typescript"); // Fixed!
       expect(enhancedIsText).toBe(true); // Fixed!
@@ -57,10 +49,6 @@ describe("Enhanced MIME Detection", () => {
       const enhancedMime = getEnhancedMimeType(tsxFile);
       const enhancedIsText = await isEnhancedTextFile(tsxFile);
 
-      console.log("TSX file detection:");
-      console.log(`  Standard MIME: ${standardMime}`);
-      console.log(`  Enhanced MIME: ${enhancedMime}, Text: ${enhancedIsText}`);
-
       expect(enhancedMime).toBe("text/tsx"); // Fixed!
       expect(enhancedIsText).toBe(true); // Fixed!
       expect(standardMime).toBe("application/octet-stream"); // Original problem
@@ -180,9 +168,6 @@ div { color: blue; }
         { name: "font.woff2", mime: "font/woff2", text: false },
       ];
 
-      console.log("\nComprehensive Developer File Detection:");
-      console.log("=====================================");
-
       for (const file of developerFiles) {
         const filePath = path.join(testDir, file.name);
 
@@ -195,13 +180,6 @@ div { color: blue; }
 
         const enhancedMime = getEnhancedMimeType(filePath);
         const enhancedIsText = await isEnhancedTextFile(filePath);
-        const forced = shouldForceAsText(filePath);
-
-        console.log(
-          `${file.name.padEnd(20)} | MIME: ${enhancedMime.padEnd(
-            25
-          )} | Text: ${enhancedIsText} | Forced: ${forced}`
-        );
 
         expect(enhancedMime).toBe(file.mime);
         expect(enhancedIsText).toBe(file.text);

package/test/unit/snapshot.test.ts

@@ -1,12 +1,7 @@
-import * as fs from "fs/promises";
 import * as path from "path";
 import * as tmp from "tmp";
 import { SnapshotManager } from "../../src/core/snapshot";
-import {
-  SyncSnapshot,
-  SnapshotFileEntry,
-  SnapshotDirectoryEntry,
-} from "../../src/types";
+import { SnapshotFileEntry, SnapshotDirectoryEntry } from "../../src/types";
 import { UrlHeads } from "@automerge/automerge-repo";
 
 describe("SnapshotManager", () => {
@@ -352,28 +347,6 @@ describe("SnapshotManager", () => {
     });
   });
 
-  describe("backup", () => {
-    it("should create backup of existing snapshot", async () => {
-      const snapshot = snapshotManager.createEmpty();
-      await snapshotManager.save(snapshot);
-
-      await snapshotManager.backup();
-
-      // Check that backup file exists
-      const syncToolDir = path.join(tmpDir, ".pushwork");
-      const files = await fs.readdir(syncToolDir);
-      const backupFiles = files.filter((f) =>
-        f.startsWith("snapshot.json.backup.")
-      );
-
-      expect(backupFiles.length).toBe(1);
-    });
-
-    it("should not fail when no snapshot exists", async () => {
-      await snapshotManager.backup(); // Should not throw
-    });
-  });
-
   describe("clone", () => {
     it("should create independent copy of snapshot", () => {
       const originalSnapshot = snapshotManager.createEmpty();
@@ -419,7 +392,7 @@ describe("SnapshotManager", () => {
       const originalTimestamp = snapshot.timestamp;
 
       // Add small delay to ensure timestamp difference
-      await new Promise((resolve) => setTimeout(resolve, 1));
+      await new Promise((resolve) => setTimeout(resolve, 10));
 
       snapshotManager.clear(snapshot);