pushwork 1.0.4 → 1.0.7

package/src/index.ts

@@ -1,14 +1,4 @@
-// Core sync functionality
 export * from "./core";
-
-// Utilities
 export * from "./utils";
-
-// Configuration
-export * from "./config";
-
-// Types
 export * from "./types";
-
-// CLI commands (for programmatic use)
 export * from "./cli";

package/src/types/config.ts

@@ -1,91 +1,37 @@
-/**
- * Global configuration options
- */
-export interface GlobalConfig {
-  sync_server?: string;
-  sync_server_storage_id?: string;
-  exclude_patterns?: string[];
-  large_file_threshold?: string;
-  diff?: {
-    external_tool?: string;
-    show_binary?: boolean;
-  };
-  sync?: {
-    move_detection_threshold?: number;
-    prompt_threshold?: number;
-    auto_sync?: boolean;
-    parallel_operations?: number;
-  };
-}
+import { StorageId } from "@automerge/automerge-repo";
 
 /**
- * Default settings
+ * Default sync server configuration
  */
-export interface DefaultSettings {
-  remote_repo?: string;
-  exclude_patterns: string[];
-  large_file_threshold: string;
-}
-
-/**
- * Diff tool settings
- */
-export interface DiffSettings {
-  external_tool?: string;
-  show_binary: boolean;
-}
+export const DEFAULT_SYNC_SERVER = "wss://sync3.automerge.org";
+export const DEFAULT_SYNC_SERVER_STORAGE_ID =
+  "3760df37-a4c6-4f66-9ecd-732039a9385d" as StorageId;
 
 /**
- * Sync behavior settings
+ * Global configuration options
  */
-export interface SyncSettings {
-  move_detection_threshold: number;
-  prompt_threshold: number;
-  auto_sync: boolean;
-  parallel_operations: number;
+export interface GlobalConfig {
+  sync_server?: string;
+  sync_server_storage_id?: StorageId;
+  exclude_patterns: string[];
+  sync: {
+    move_detection_threshold: number;
+  };
 }
 
 /**
  * Per-directory configuration
  */
-export interface DirectoryConfig {
-  sync_server?: string;
-  sync_server_storage_id?: string;
+export interface DirectoryConfig extends GlobalConfig {
+  root_directory_url?: string;
   sync_enabled: boolean;
-  root_directory_url?: string; // AutomergeUrl of the root directory document
-  defaults: {
-    exclude_patterns: string[];
-    large_file_threshold: string;
-  };
-  diff: {
-    external_tool?: string;
-    show_binary: boolean;
-  };
-  sync: {
-    move_detection_threshold: number;
-    prompt_threshold: number;
-    auto_sync: boolean;
-    parallel_operations: number;
-  };
 }
 
 /**
  * CLI command options
  */
 export interface CommandOptions {
-  dryRun?: boolean;
   verbose?: boolean;
-  tool?: string;
-  nameOnly?: boolean;
-  oneline?: boolean;
-  remote?: string;
-}
-
-/**
- * Init command specific options
- */
-export interface InitOptions extends CommandOptions {
-  // No additional options needed - init creates a new sync directory
 }
 
 /**
@@ -94,22 +40,21 @@ export interface InitOptions extends CommandOptions {
 export interface CloneOptions extends CommandOptions {
   force?: boolean; // Overwrite existing directory
   syncServer?: string; // Custom sync server URL
-  syncServerStorageId?: string; // Custom sync server storage ID
+  syncServerStorageId?: StorageId; // Custom sync server storage ID
 }
 
 /**
  * Sync command specific options
  */
 export interface SyncOptions extends CommandOptions {
-  dryRun: boolean;
   force?: boolean;
+  dryRun?: boolean;
 }
 
 /**
  * Diff command specific options
  */
 export interface DiffOptions extends CommandOptions {
-  tool?: string;
   nameOnly: boolean;
 }
 
@@ -128,3 +73,36 @@ export interface LogOptions extends CommandOptions {
 export interface CheckoutOptions extends CommandOptions {
   force?: boolean;
 }
+
+/**
+ * Init command specific options
+ */
+export interface InitOptions extends CommandOptions {
+  syncServer?: string;
+  syncServerStorageId?: StorageId;
+}
+
+/**
+ * Config command specific options
+ */
+export interface ConfigOptions extends CommandOptions {
+  list?: boolean;
+  get?: string;
+  set?: string;
+  value?: string;
+}
+
+/**
+ * Status command specific options
+ */
+export interface StatusOptions extends CommandOptions {
+  verbose?: boolean;
+}
+
+/**
+ * Watch command specific options
+ */
+export interface WatchOptions extends CommandOptions {
+  script?: string; // Script to run before syncing
+  watchDir?: string; // Directory to watch (relative to working dir)
+}

package/src/types/documents.ts

@@ -1,4 +1,5 @@
-import { AutomergeUrl } from "@automerge/automerge-repo";
+import { AutomergeUrl, UrlHeads } from "@automerge/automerge-repo";
+import * as A from "@automerge/automerge";
 
 /**
  * Entry in a directory document
@@ -26,7 +27,7 @@ export interface FileDocument {
   name: string;
   extension: string;
   mimeType: string;
-  content: string | Uint8Array;
+  content: A.ImmutableString | Uint8Array;
   metadata: {
     permissions: number;
   };
@@ -69,6 +70,18 @@ export interface MoveCandidate {
   fromPath: string;
   toPath: string;
   similarity: number;
-  confidence: "auto" | "prompt" | "low";
   newContent?: string | Uint8Array; // Content at destination (may differ from source if modified during move)
 }
+
+/**
+ * Represents a detected change
+ */
+export interface DetectedChange {
+  path: string;
+  changeType: ChangeType;
+  fileType: FileType;
+  localContent: string | Uint8Array | null;
+  remoteContent: string | Uint8Array | null;
+  localHead?: UrlHeads;
+  remoteHead?: UrlHeads;
+}

package/src/types/index.ts

@@ -1,8 +1,3 @@
-// Document types
 export * from "./documents";
-
-// Snapshot and sync types
 export * from "./snapshot";
-
-// Configuration types
 export * from "./config";

package/src/types/snapshot.ts

@@ -52,6 +52,7 @@ export interface SyncResult {
   directoriesChanged: number;
   errors: SyncError[];
   warnings: string[];
+  timings?: { [key: string]: number };
 }
 
 /**
@@ -63,26 +64,3 @@ export interface SyncError {
   error: Error;
   recoverable: boolean;
 }
-
-/**
- * Sync operation type
- */
-export enum SyncOperation {
-  CREATE_FILE = "create_file",
-  UPDATE_FILE = "update_file",
-  DELETE_FILE = "delete_file",
-  MOVE_FILE = "move_file",
-  CREATE_DIRECTORY = "create_directory",
-  DELETE_DIRECTORY = "delete_directory",
-  MOVE_DIRECTORY = "move_directory",
-}
-
-/**
- * Pending sync operation
- */
-export interface PendingSyncOperation {
-  operation: SyncOperation;
-  path: string;
-  newPath?: string;
-  priority: number;
-}

package/src/utils/content.ts

@@ -13,16 +13,12 @@ export function isContentEqual(
   if (typeof content1 === "string") {
     return content1 === content2;
   } else {
-    // Compare Uint8Array
+    // Compare Uint8Array using native Buffer.equals() for better performance
     const buf1 = content1 as Uint8Array;
     const buf2 = content2 as Uint8Array;
 
     if (buf1.length !== buf2.length) return false;
 
-    for (let i = 0; i < buf1.length; i++) {
-      if (buf1[i] !== buf2[i]) return false;
-    }
-
-    return true;
+    return Buffer.from(buf1).equals(Buffer.from(buf2));
   }
 }

package/src/utils/directory.ts

@@ -0,0 +1,50 @@
+import { AutomergeUrl, Repo } from "@automerge/automerge-repo";
+import { DirectoryDocument } from "../types";
+
+/**
+ * Find a file in the directory hierarchy by path
+ */
+export async function findFileInDirectoryHierarchy(
+  repo: Repo,
+  directoryUrl: AutomergeUrl,
+  filePath: string
+): Promise<{ name: string; type: string; url: AutomergeUrl } | null> {
+  try {
+    const pathParts = filePath.split("/");
+    let currentDirUrl = directoryUrl;
+
+    // Navigate through directories to find the parent directory
+    for (let i = 0; i < pathParts.length - 1; i++) {
+      const dirName = pathParts[i];
+      const dirHandle = await repo.find<DirectoryDocument>(currentDirUrl);
+      const dirDoc = await dirHandle.doc();
+
+      if (!dirDoc) return null;
+
+      const subDirEntry = dirDoc.docs.find(
+        (entry: { name: string; type: string; url: AutomergeUrl }) =>
+          entry.name === dirName && entry.type === "folder"
+      );
+
+      if (!subDirEntry) return null;
+      currentDirUrl = subDirEntry.url;
+    }
+
+    // Now look for the file in the final directory
+    const fileName = pathParts[pathParts.length - 1];
+    const finalDirHandle = await repo.find<DirectoryDocument>(currentDirUrl);
+    const finalDirDoc = await finalDirHandle.doc();
+
+    if (!finalDirDoc) return null;
+
+    const fileEntry = finalDirDoc.docs.find(
+      (entry: { name: string; type: string; url: AutomergeUrl }) =>
+        entry.name === fileName && entry.type === "file"
+    );
+
+    return fileEntry || null;
+  } catch (error) {
+    // Failed to find file in hierarchy
+    return null;
+  }
+}

package/src/utils/fs.ts

@@ -3,6 +3,8 @@ import * as path from "path";
 import * as crypto from "crypto";
 import { glob } from "glob";
 import * as mimeTypes from "mime-types";
+import * as ignore from "ignore";
+import * as A from "@automerge/automerge";
 import { FileSystemEntry, FileType } from "../types";
 import { isEnhancedTextFile } from "./mime-types";
 
@@ -94,12 +96,15 @@ export async function readFileContent(
  */
 export async function writeFileContent(
   filePath: string,
-  content: string | Uint8Array
+  content: string | A.ImmutableString | Uint8Array
 ): Promise<void> {
   await ensureDirectoryExists(path.dirname(filePath));
 
   if (typeof content === "string") {
     await fs.writeFile(filePath, content, "utf8");
+  } else if (A.isImmutableString(content)) {
+    // Convert ImmutableString to regular string for filesystem operations
+    await fs.writeFile(filePath, content.toString(), "utf8");
   } else {
     await fs.writeFile(filePath, content);
   }
@@ -125,7 +130,7 @@ export async function removePath(filePath: string): Promise<void> {
   try {
     const stats = await fs.stat(filePath);
     if (stats.isDirectory()) {
-      await fs.rmdir(filePath, { recursive: true });
+      await fs.rm(filePath, { recursive: true });
     } else {
       await fs.unlink(filePath);
     }
@@ -137,48 +142,23 @@ export async function removePath(filePath: string): Promise<void> {
 }
 
 /**
- * Check if a path matches any of the exclude patterns
+ * Check if a path matches any of the exclude patterns using the ignore library
+ * Supports proper gitignore-style patterns (e.g., "node_modules", "*.tmp", ".git")
  */
 function isExcluded(
   filePath: string,
   basePath: string,
   excludePatterns: string[]
 ): boolean {
+  if (excludePatterns.length === 0) return false;
+
   const relativePath = path.relative(basePath, filePath);
 
-  for (const pattern of excludePatterns) {
-    // Handle different pattern types
-    if (pattern.startsWith(".") && !pattern.includes("*")) {
-      // Directory pattern like ".pushwork" or ".git"
-      if (
-        relativePath.startsWith(pattern) ||
-        relativePath.includes(`/${pattern}/`) ||
-        relativePath.includes(`\\${pattern}\\`)
-      ) {
-        return true;
-      }
-    } else if (pattern.includes("*")) {
-      // Glob pattern like "*.tmp"
-      // CRITICAL FIX: Properly escape dots and anchor the pattern
-      // Convert glob to regex: *.tmp -> ^.*\.tmp$ (not /.*.tmp/ which matches "fuftmp.ts"!)
-      const regexPattern = pattern
-        .replace(/\./g, "\\.") // Escape dots first
-        .replace(/\*/g, ".*") // Then convert * to .*
-        .replace(/\?/g, "."); // And ? to single char
-      const regex = new RegExp(`^${regexPattern}$`); // Anchor to match full path
-      if (regex.test(relativePath)) {
-        return true;
-      }
-    } else {
-      // Exact directory name like "node_modules"
-      const parts = relativePath.split(/[/\\]/);
-      if (parts.includes(pattern)) {
-        return true;
-      }
-    }
-  }
+  // Use the ignore library which implements proper .gitignore semantics
+  // This is the same library used by ESLint and other major tools
+  const ig = ignore.default().add(excludePatterns);
 
-  return false;
+  return ig.ignores(relativePath);
 }
 
 /**
@@ -192,33 +172,34 @@ export async function listDirectory(
   const entries: FileSystemEntry[] = [];
 
   try {
+    // Construct pattern using path.join for proper cross-platform handling
     const pattern = recursive
       ? path.join(dirPath, "**/*")
       : path.join(dirPath, "*");
+    
+    // CRITICAL: glob expects forward slashes, even on Windows
+    // Convert backslashes to forward slashes for glob pattern
+    const normalizedPattern = pattern.replace(/\\/g, "/");
 
-    // Convert exclude patterns to glob ignore patterns
-    const ignorePatterns = excludePatterns.map((pattern) => {
-      if (pattern.startsWith(".") && !pattern.includes("*")) {
-        // Directory patterns
-        return `${pattern}/**`;
-      }
-      return pattern;
-    });
-
-    const paths = await glob(pattern, {
+    // Use glob to get all paths (with dot files)
+    // Note: We don't use glob's ignore option because it doesn't support gitignore semantics
+    const paths = await glob(normalizedPattern, {
       dot: true,
-      ignore: ignorePatterns,
     });
 
-    for (const filePath of paths) {
-      // Additional filtering for safety
-      if (!isExcluded(filePath, dirPath, excludePatterns)) {
-        const entry = await getFileSystemEntry(filePath);
-        if (entry) {
-          entries.push(entry);
+    // Parallelize all stat calls for better performance
+    const allEntries = await Promise.all(
+      paths.map(async (filePath) => {
+        // Filter using proper gitignore semantics from the ignore library
+        if (isExcluded(filePath, dirPath, excludePatterns)) {
+          return null;
         }
-      }
-    }
+        return await getFileSystemEntry(filePath);
+      })
+    );
+
+    // Filter out null entries (excluded files or files that couldn't be read)
+    entries.push(...allEntries.filter((e): e is FileSystemEntry => e !== null));
   } catch {
     // Return empty array if directory doesn't exist or can't be read
   }
@@ -256,10 +237,14 @@ export async function movePath(
  * Calculate content hash for change detection
  */
 export async function calculateContentHash(
-  content: string | Uint8Array
+  content: string | A.ImmutableString | Uint8Array
 ): Promise<string> {
   const hash = crypto.createHash("sha256");
-  hash.update(content);
+  if (A.isImmutableString(content)) {
+    hash.update(content.toString());
+  } else {
+    hash.update(content);
+  }
   return hash.digest("hex");
 }
 
@@ -280,14 +265,40 @@ export function getFileExtension(filePath: string): string {
 
 /**
  * Normalize path separators for cross-platform compatibility
+ * Converts all path separators to forward slashes for consistent storage
  */
 export function normalizePath(filePath: string): string {
   return path.posix.normalize(filePath.replace(/\\/g, "/"));
 }
 
+/**
+ * Join paths and normalize separators for cross-platform compatibility
+ * Use this instead of string concatenation to ensure proper path handling on Windows
+ */
+export function joinAndNormalizePath(...paths: string[]): string {
+  // Use path.join to properly handle path construction (handles Windows drive letters, etc.)
+  const joined = path.join(...paths);
+  // Then normalize to forward slashes for consistent storage/comparison
+  return normalizePath(joined);
+}
+
 /**
  * Get relative path from base directory
  */
 export function getRelativePath(basePath: string, filePath: string): string {
   return normalizePath(path.relative(basePath, filePath));
 }
+
+/**
+ * Format a path as a relative path with proper prefix
+ * Ensures paths like "src" become "./src" for clarity
+ * Leaves absolute paths and paths already starting with . or .. unchanged
+ */
+export function formatRelativePath(filePath: string): string {
+  // Already starts with . or / - leave as-is
+  if (filePath.startsWith(".") || filePath.startsWith("/")) {
+    return filePath;
+  }
+  // Add ./ prefix for clarity
+  return `./${filePath}`;
+}

package/src/utils/index.ts

@@ -1,8 +1,3 @@
-// File system utilities
 export * from "./fs";
-
-// Content similarity utilities
-export * from "./content-similarity";
-
-// Enhanced MIME type detection
 export * from "./mime-types";
+export * from "./directory";

package/src/utils/mime-types.ts

@@ -109,8 +109,9 @@ const FORCE_TEXT_EXTENSIONS = new Set([
  * Get enhanced MIME type for file with custom dev file support
  */
 export function getEnhancedMimeType(filePath: string): string {
-  const filename = filePath.split("/").pop() || "";
-  const extension = getFileExtension(filePath);
+  const normalized = normalizePathSeparators(filePath);
+  const filename = normalized.split("/").pop() || "";
+  const extension = getFileExtension(normalized);
 
   // Check custom definitions first (by extension)
   if (extension && CUSTOM_MIME_TYPES[extension]) {
@@ -123,7 +124,7 @@ export function getEnhancedMimeType(filePath: string): string {
   }
 
   // Fall back to standard mime-types library
-  const standardMime = mimeTypes.lookup(filePath);
+  const standardMime = mimeTypes.lookup(normalized);
   if (standardMime) {
     return standardMime;
   }
@@ -145,7 +146,14 @@ export function shouldForceAsText(filePath: string): boolean {
  */
 function getFileExtension(filePath: string): string {
   const match = filePath.match(/\.[^.]*$/);
-  return match ? match[0] : "";
+  return match ? match[0].toLowerCase() : "";
+}
+
+/**
+ * Normalize path separators to forward slashes for cross-platform consistency
+ */
+function normalizePathSeparators(p: string): string {
+  return p.replace(/\\/g, "/");
 }
 
 /**