pushwork 1.0.4 → 1.0.7

package/src/{config/index.ts → core/config.ts}

@@ -1,7 +1,12 @@
 import * as fs from "fs/promises";
 import * as path from "path";
 import * as os from "os";
-import { GlobalConfig, DirectoryConfig } from "../types";
+import {
+  GlobalConfig,
+  DirectoryConfig,
+  DEFAULT_SYNC_SERVER,
+  DEFAULT_SYNC_SERVER_STORAGE_ID,
+} from "../types";
 import { pathExists, ensureDirectoryExists } from "../utils";
 
 /**
@@ -10,7 +15,8 @@ import { pathExists, ensureDirectoryExists } from "../utils";
 export class ConfigManager {
   private static readonly GLOBAL_CONFIG_DIR = ".pushwork";
   private static readonly CONFIG_FILENAME = "config.json";
-  private static readonly LOCAL_CONFIG_DIR = ".pushwork";
+
+  static readonly CONFIG_DIR = ".pushwork";
 
   constructor(private workingDir?: string) {}
 
@@ -34,7 +40,7 @@ export class ConfigManager {
     }
     return path.join(
       this.workingDir,
-      ConfigManager.LOCAL_CONFIG_DIR,
+      ConfigManager.CONFIG_DIR,
       ConfigManager.CONFIG_FILENAME
     );
   }
@@ -52,7 +58,7 @@ export class ConfigManager {
       const content = await fs.readFile(configPath, "utf8");
       return JSON.parse(content) as GlobalConfig;
     } catch (error) {
-      console.warn(`Failed to load global config: ${error}`);
+      // Failed to load global config
       return null;
     }
   }
@@ -89,7 +95,7 @@ export class ConfigManager {
       const content = await fs.readFile(configPath, "utf8");
       return JSON.parse(content) as DirectoryConfig;
     } catch (error) {
-      console.warn(`Failed to load local config: ${error}`);
+      // Failed to load local config
       return null;
     }
   }
@@ -113,34 +119,53 @@ export class ConfigManager {
     }
   }
 
+  private getDefaultGlobalConfig(): GlobalConfig {
+    return {
+      exclude_patterns: [
+        ".git",
+        "node_modules",
+        "*.tmp",
+        ".DS_Store",
+        ".pushwork",
+      ],
+      sync_server: DEFAULT_SYNC_SERVER,
+      sync_server_storage_id: DEFAULT_SYNC_SERVER_STORAGE_ID,
+      sync: {
+        move_detection_threshold: 0.7,
+      },
+    };
+  }
+
   /**
-   * Get merged configuration (global + local)
+   * Get default configuration
    */
-  async getMerged(): Promise<DirectoryConfig> {
-    const globalConfig = await this.loadGlobal();
-    const localConfig = await this.load();
-
-    // Create default configuration
-    const defaultConfig: DirectoryConfig = {
+  private getDefaultConfig(): DirectoryConfig {
+    return {
       sync_enabled: true,
-      sync_server_storage_id: "3760df37-a4c6-4f66-9ecd-732039a9385d",
-      defaults: {
-        exclude_patterns: [".git", "node_modules", "*.tmp", ".pushwork"],
-        large_file_threshold: "100MB",
-      },
-      diff: {
-        show_binary: false,
-      },
+      sync_server: DEFAULT_SYNC_SERVER,
+      sync_server_storage_id: DEFAULT_SYNC_SERVER_STORAGE_ID,
+      exclude_patterns: [
+        ".git",
+        "node_modules",
+        "*.tmp",
+        ".pushwork",
+        ".DS_Store",
+      ],
       sync: {
-        move_detection_threshold: 0.8,
-        prompt_threshold: 0.5,
-        auto_sync: false,
-        parallel_operations: 4,
+        move_detection_threshold: 0.7,
       },
     };
+  }
+
+  /**
+   * Get merged configuration (global + local)
+   */
+  async getMerged(): Promise<DirectoryConfig> {
+    const globalConfig = await this.loadGlobal();
+    const localConfig = await this.load();
 
     // Merge configurations: default < global < local
-    let merged = { ...defaultConfig };
+    let merged = this.getDefaultConfig();
 
     if (globalConfig) {
       merged = this.mergeConfigs(merged, globalConfig);
@@ -153,6 +178,18 @@ export class ConfigManager {
     return merged;
   }
 
+  /**
+   * Initialize with CLI option overrides
+   * Creates a new config with defaults + CLI overrides and saves it
+   */
+  async initializeWithOverrides(
+    overrides: Partial<DirectoryConfig> = {}
+  ): Promise<DirectoryConfig> {
+    const config = this.mergeConfigs(this.getDefaultConfig(), overrides);
+    await this.save(config);
+    return config;
+  }
+
   /**
    * Merge two configuration objects
    */
@@ -179,25 +216,7 @@ export class ConfigManager {
 
     // Handle GlobalConfig structure
     if ("exclude_patterns" in override && override.exclude_patterns) {
-      merged.defaults.exclude_patterns = override.exclude_patterns;
-    }
-
-    if ("large_file_threshold" in override && override.large_file_threshold) {
-      merged.defaults.large_file_threshold = override.large_file_threshold;
-    }
-
-    // Handle DirectoryConfig structure
-    if ("defaults" in override && override.defaults) {
-      merged.defaults = { ...merged.defaults, ...override.defaults };
-    }
-
-    if ("diff" in override && override.diff) {
-      // Merge diff settings, ensuring show_binary has a default
-      merged.diff = {
-        ...merged.diff,
-        ...override.diff,
-        show_binary: override.diff.show_binary ?? merged.diff.show_binary,
-      };
+      merged.exclude_patterns = override.exclude_patterns;
     }
 
     if ("sync" in override && override.sync) {
@@ -211,28 +230,7 @@ export class ConfigManager {
    * Create default global configuration
    */
   async createDefaultGlobal(): Promise<void> {
-    const defaultGlobal: GlobalConfig = {
-      exclude_patterns: [
-        ".git",
-        "node_modules",
-        "*.tmp",
-        ".DS_Store",
-        ".pushwork",
-      ],
-      large_file_threshold: "100MB",
-      sync_server: "wss://sync3.automerge.org",
-      sync_server_storage_id: "3760df37-a4c6-4f66-9ecd-732039a9385d",
-      diff: {
-        show_binary: false,
-      },
-      sync: {
-        move_detection_threshold: 0.8,
-        prompt_threshold: 0.5,
-        auto_sync: false,
-        parallel_operations: 4,
-      },
-    };
-
+    const defaultGlobal = this.getDefaultGlobalConfig();
     await this.saveGlobal(defaultGlobal);
   }
 
@@ -252,7 +250,7 @@ export class ConfigManager {
   }
 
   /**
-   * Get configuration value by path (e.g., 'sync.auto_sync')
+   * Get configuration value by path (e.g., 'sync.move_detection_threshold')
    */
   async getValue(keyPath: string): Promise<any> {
     const config = await this.getMerged();
@@ -311,21 +309,6 @@ export class ConfigManager {
       }
     }
 
-    if (config.sync?.prompt_threshold !== undefined) {
-      if (
-        config.sync.prompt_threshold < 0 ||
-        config.sync.prompt_threshold > 1
-      ) {
-        errors.push("prompt_threshold must be between 0 and 1");
-      }
-    }
-
-    if (config.sync?.parallel_operations !== undefined) {
-      if (config.sync.parallel_operations < 1) {
-        errors.push("parallel_operations must be at least 1");
-      }
-    }
-
     return {
       valid: errors.length === 0,
       errors,

package/src/core/index.ts

@@ -1,5 +1,5 @@
-// Core sync components
 export * from "./snapshot";
 export * from "./change-detection";
 export * from "./move-detection";
 export * from "./sync-engine";
+export * from "./config";

package/src/core/move-detection.ts

@@ -1,28 +1,25 @@
-import {
-  SyncSnapshot,
-  MoveCandidate,
-  FileType,
-  SnapshotFileEntry,
-} from "../types";
-import { ContentSimilarity, readFileContent, getRelativePath } from "../utils";
-import { DetectedChange, ChangeType } from "./change-detection";
+import { SyncSnapshot, MoveCandidate } from "../types";
+import { isTextFile } from "../utils";
+import { stringSimilarity } from "../utils/string-similarity";
+import { ChangeType, DetectedChange } from "../types";
 
 /**
- * Move detection engine
+ * Simplified move detection engine
  */
 export class MoveDetector {
-  private static readonly AUTO_THRESHOLD = 0.8;
-  private static readonly PROMPT_THRESHOLD = 0.5;
+  private readonly moveThreshold: number;
+
+  constructor(moveThreshold: number = 0.7) {
+    this.moveThreshold = moveThreshold;
+  }
 
   /**
    * Detect file moves by analyzing deleted and created files
    */
   async detectMoves(
     changes: DetectedChange[],
-    snapshot: SyncSnapshot,
-    rootPath: string
+    snapshot: SyncSnapshot
   ): Promise<{ moves: MoveCandidate[]; remainingChanges: DetectedChange[] }> {
-    // Separate deletions and creations
     const deletedFiles = changes.filter(
       (c) => !c.localContent && c.changeType === ChangeType.LOCAL_ONLY
     );
@@ -43,28 +40,22 @@ export class MoveDetector {
 
     // Find potential moves by comparing content
     for (const deletedFile of deletedFiles) {
-      const deletedContent = await this.getDeletedFileContent(
-        deletedFile,
-        snapshot
-      );
-      // CRITICAL: Check for null explicitly, not falsy values
-      // Empty strings "" are valid file content!
+      const deletedContent = deletedFile.remoteContent;
       if (deletedContent === null) continue;
 
       let bestMatch: { file: DetectedChange; similarity: number } | null = null;
 
       for (const createdFile of createdFiles) {
         if (usedCreations.has(createdFile.path)) continue;
-        // CRITICAL: Check for null explicitly, not falsy values
-        // Empty strings "" are valid file content!
         if (createdFile.localContent === null) continue;
 
-        const similarity = await ContentSimilarity.calculateSimilarity(
+        const similarity = await this.calculateSimilarity(
           deletedContent,
-          createdFile.localContent
+          createdFile.localContent,
+          deletedFile.path
         );
 
-        if (similarity >= MoveDetector.PROMPT_THRESHOLD) {
+        if (similarity >= this.moveThreshold) {
           if (!bestMatch || similarity > bestMatch.similarity) {
             bestMatch = { file: createdFile, similarity };
           }
@@ -72,31 +63,20 @@ export class MoveDetector {
       }
 
       if (bestMatch) {
-        const confidence = ContentSimilarity.getConfidenceLevel(
-          bestMatch.similarity
-        );
-
-        // Always report the potential move (for logging/prompting)
+        // If we detected a move above threshold, we apply it
         moves.push({
           fromPath: deletedFile.path,
           toPath: bestMatch.file.path,
           similarity: bestMatch.similarity,
-          confidence,
-          // Capture new content (may include modifications)
           newContent: bestMatch.file.localContent || undefined,
         });
 
-        // Only consume the deletion/creation pair when we would auto-apply the move.
-        // If we only want to prompt, leave the original changes in place so
-        // sync can still proceed as delete+create (avoids infinite warning loop).
-        if (bestMatch.similarity >= MoveDetector.AUTO_THRESHOLD) {
-          usedCreations.add(bestMatch.file.path);
-          usedDeletions.add(deletedFile.path);
-        }
+        // Consume the deletion and creation (move replaces both)
+        usedCreations.add(bestMatch.file.path);
+        usedDeletions.add(deletedFile.path);
       }
     }
 
-    // Filter out changes that are part of moves
     const remainingChanges = changes.filter(
       (change) =>
         !usedCreations.has(change.path) && !usedDeletions.has(change.path)
@@ -106,145 +86,77 @@ export class MoveDetector {
   }
 
   /**
-   * Get content of a deleted file from snapshot
-   */
-  private async getDeletedFileContent(
-    deletedFile: DetectedChange,
-    snapshot: SyncSnapshot
-  ): Promise<string | Uint8Array | null> {
-    const snapshotEntry = snapshot.files.get(deletedFile.path);
-    if (!snapshotEntry) return null;
-
-    // Return remote content if available, otherwise null
-    return deletedFile.remoteContent || null;
-  }
-
-  /**
-   * Group moves by confidence level
+   * Calculate similarity between two content pieces
+   * Optimized for speed while maintaining accuracy
    */
-  groupMovesByConfidence(moves: MoveCandidate[]): {
-    autoMoves: MoveCandidate[];
-    promptMoves: MoveCandidate[];
-    lowConfidenceMoves: MoveCandidate[];
-  } {
-    const autoMoves = moves.filter((m) => m.confidence === "auto");
-    const promptMoves = moves.filter((m) => m.confidence === "prompt");
-    const lowConfidenceMoves = moves.filter((m) => m.confidence === "low");
-
-    return { autoMoves, promptMoves, lowConfidenceMoves };
-  }
-
-  /**
-   * Validate move candidates to avoid conflicts
-   */
-  validateMoves(moves: MoveCandidate[]): {
-    validMoves: MoveCandidate[];
-    conflicts: Array<{ moves: MoveCandidate[]; reason: string }>;
-  } {
-    const validMoves: MoveCandidate[] = [];
-    const conflicts: Array<{ moves: MoveCandidate[]; reason: string }> = [];
-
-    // Check for multiple sources mapping to same destination
-    const destinationMap = new Map<string, MoveCandidate[]>();
-    for (const move of moves) {
-      if (!destinationMap.has(move.toPath)) {
-        destinationMap.set(move.toPath, []);
-      }
-      destinationMap.get(move.toPath)!.push(move);
-    }
-
-    // Check for multiple destinations from same source
-    const sourceMap = new Map<string, MoveCandidate[]>();
-    for (const move of moves) {
-      if (!sourceMap.has(move.fromPath)) {
-        sourceMap.set(move.fromPath, []);
-      }
-      sourceMap.get(move.fromPath)!.push(move);
+  private async calculateSimilarity(
+    content1: string | Uint8Array,
+    content2: string | Uint8Array,
+    path: string
+  ): Promise<number> {
+    if (content1 === content2) return 1.0;
+
+    // Early exit: size difference too large
+    const size1 =
+      typeof content1 === "string" ? content1.length : content1.length;
+    const size2 =
+      typeof content2 === "string" ? content2.length : content2.length;
+    const sizeDiff = Math.abs(size1 - size2) / Math.max(size1, size2);
+    if (sizeDiff > 0.5) return 0.0;
+
+    // Binary files: hash mismatch = not a move
+    const isText = await isTextFile(path);
+    if (!isText) return 0.0;
+
+    // Text files: use string similarity
+    const str1 =
+      typeof content1 === "string" ? content1 : this.bufferToString(content1);
+    const str2 =
+      typeof content2 === "string" ? content2 : this.bufferToString(content2);
+
+    // For small files (<4KB), compare full content
+    if (size1 < 4096 && size2 < 4096) {
+      return stringSimilarity(str1, str2);
     }
 
-    for (const move of moves) {
-      const destinationConflicts = destinationMap.get(move.toPath)!;
-      const sourceConflicts = sourceMap.get(move.fromPath)!;
+    // For large files, sample 3 locations
+    const samples1 = this.getSamples(str1);
+    const samples2 = this.getSamples(str2);
 
-      if (destinationConflicts.length > 1) {
-        conflicts.push({
-          moves: destinationConflicts,
-          reason: `Multiple files moving to ${move.toPath}`,
-        });
-      } else if (sourceConflicts.length > 1) {
-        conflicts.push({
-          moves: sourceConflicts,
-          reason: `File ${move.fromPath} has multiple potential destinations`,
-        });
-      } else {
-        validMoves.push(move);
-      }
+    let totalSimilarity = 0;
+    for (let i = 0; i < Math.min(samples1.length, samples2.length); i++) {
+      totalSimilarity += stringSimilarity(samples1[i], samples2[i]);
     }
 
-    return { validMoves, conflicts };
-  }
-
-  /**
-   * Apply move detection heuristics
-   */
-  applyHeuristics(moves: MoveCandidate[]): MoveCandidate[] {
-    return moves
-      .filter((move) => {
-        // Filter out moves within the same directory unless similarity is very high
-        const fromDir = this.getDirectoryPath(move.fromPath);
-        const toDir = this.getDirectoryPath(move.toPath);
-
-        if (fromDir === toDir && move.similarity < 0.9) {
-          return false;
-        }
-
-        // Filter out moves with very different file extensions unless similarity is perfect
-        const fromExt = this.getFileExtension(move.fromPath);
-        const toExt = this.getFileExtension(move.toPath);
-
-        if (fromExt !== toExt && move.similarity < 1.0) {
-          return false;
-        }
-
-        return true;
-      })
-      .sort((a, b) => b.similarity - a.similarity); // Sort by similarity descending
-  }
-
-  /**
-   * Get directory path from file path
-   */
-  private getDirectoryPath(filePath: string): string {
-    const lastSlash = filePath.lastIndexOf("/");
-    return lastSlash >= 0 ? filePath.substring(0, lastSlash) : "";
+    return totalSimilarity / Math.min(samples1.length, samples2.length);
   }
 
   /**
-   * Get file extension from file path
+   * Get representative samples from content (beginning, middle, end)
    */
-  private getFileExtension(filePath: string): string {
-    const lastDot = filePath.lastIndexOf(".");
-    const lastSlash = filePath.lastIndexOf("/");
+  private getSamples(str: string): string[] {
+    const CHUNK_SIZE = 1024;
+    const length = str.length;
 
-    if (lastDot > lastSlash && lastDot >= 0) {
-      return filePath.substring(lastDot + 1).toLowerCase();
+    if (length <= CHUNK_SIZE) {
+      return [str];
     }
 
-    return "";
-  }
-
-  /**
-   * Check if a move should be auto-applied
-   */
-  shouldAutoApply(move: MoveCandidate): boolean {
-    return move.confidence === "auto";
+    return [
+      str.slice(0, CHUNK_SIZE), // Beginning
+      str.slice(
+        Math.floor(length / 2) - Math.floor(CHUNK_SIZE / 2),
+        Math.floor(length / 2) + Math.floor(CHUNK_SIZE / 2)
+      ), // Middle
+      str.slice(-CHUNK_SIZE), // End
+    ];
   }
 
   /**
-   * Check if a move should prompt the user
+   * Convert buffer to string (for text comparison)
    */
-  shouldPromptUser(move: MoveCandidate): boolean {
-    return move.confidence === "prompt";
+  private bufferToString(buffer: Uint8Array): string {
+    return new TextDecoder().decode(buffer);
   }
 
   /**
@@ -254,22 +166,4 @@ export class MoveDetector {
     const percentage = Math.round(move.similarity * 100);
     return `${move.fromPath} → ${move.toPath} (${percentage}% similar)`;
   }
-
-  /**
-   * Calculate move statistics
-   */
-  calculateStats(moves: MoveCandidate[]): {
-    total: number;
-    auto: number;
-    prompt: number;
-    averageSimilarity: number;
-  } {
-    const total = moves.length;
-    const auto = moves.filter((m) => m.confidence === "auto").length;
-    const prompt = moves.filter((m) => m.confidence === "prompt").length;
-    const averageSimilarity =
-      total > 0 ? moves.reduce((sum, m) => sum + m.similarity, 0) / total : 0;
-
-    return { total, auto, prompt, averageSimilarity };
-  }
 }

package/src/core/snapshot.ts

@@ -11,6 +11,7 @@ import {
   SnapshotDirectoryEntry,
 } from "../types";
 import { pathExists, ensureDirectoryExists } from "../utils";
+import { out } from "../utils/output";
 
 /**
  * Manages sync snapshots for local state tracking
@@ -57,7 +58,7 @@ export class SnapshotManager {
 
       return this.deserializeSnapshot(serializable);
     } catch (error) {
-      console.warn(`Failed to load snapshot: ${error}`);
+      out.taskLine(`Failed to load snapshot: ${error}`);
       return null;
     }
   }
@@ -189,17 +190,6 @@ export class SnapshotManager {
     };
   }
 
-  /**
-   * Backup current snapshot
-   */
-  async backup(): Promise<void> {
-    const snapshotPath = this.getSnapshotPath();
-    if (await pathExists(snapshotPath)) {
-      const backupPath = `${snapshotPath}.backup.${Date.now()}`;
-      await fs.copyFile(snapshotPath, backupPath);
-    }
-  }
-
   /**
    * Validate snapshot integrity
    */